trackler 2.2.1.137 → 2.2.1.138

data/tracks/java/exercises/pythagorean-triplet/src/test/java/PythagoreanTripletTest.java

@@ -15,8 +15,8 @@ public class PythagoreanTripletTest {
     @Test
     public void shouldCalculateSum() {
         PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
-        final int expected = 12;
-        final int actual = triplet.calculateSum();
+        int expected = 12;
+        int actual = triplet.calculateSum();
         assertEquals(expected, actual);
     }
 
@@ -24,8 +24,8 @@ public class PythagoreanTripletTest {
     @Test
     public void shouldCalculateProduct() {
         PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
-        final long expected = 60l;
-        final long actual = triplet.calculateProduct();
+        long expected = 60l;
+        long actual = triplet.calculateProduct();
         assertEquals(expected, actual);
     }
 
@@ -46,7 +46,7 @@ public class PythagoreanTripletTest {
     @Ignore("Remove to run test")
     @Test
     public void shouldMakeTripletsUpToTen() {
-        final List<Long> actual
+        List<Long> actual
                 = PythagoreanTriplet
                         .makeTripletsList()
                         .withFactorsLessThanOrEqualTo(10)
@@ -55,14 +55,14 @@ public class PythagoreanTripletTest {
                         .map(t -> t.calculateProduct())
                         .sorted()
                         .collect(Collectors.toList());
-        final List<Long> expected = Arrays.asList(60l, 480l);
+        List<Long> expected = Arrays.asList(60l, 480l);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void shouldMakeTripletsElevenToTwenty() {
-        final List<Long> actual
+        List<Long> actual
                 = PythagoreanTriplet
                         .makeTripletsList()
                         .withFactorsGreaterThanOrEqualTo(11)
@@ -72,14 +72,14 @@ public class PythagoreanTripletTest {
                         .map(t -> t.calculateProduct())
                         .sorted((p1, p2) -> Double.compare(p1, p2))
                         .collect(Collectors.toList());
-        final List<Long> expected = Arrays.asList(3840l);
+        List<Long> expected = Arrays.asList(3840l);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void shouldMakeTripletsAndFilterOnSum() {
-        final List<Long> actual
+        List<Long> actual
                 = PythagoreanTriplet
                         .makeTripletsList()
                         .withFactorsLessThanOrEqualTo(100)
@@ -89,7 +89,7 @@ public class PythagoreanTripletTest {
                         .map(t -> t.calculateProduct())
                         .sorted((p1, p2) -> Double.compare(p1, p2))
                         .collect(Collectors.toList());
-        final List<Long> expected = Arrays.asList(118080l, 168480l, 202500l);
+        List<Long> expected = Arrays.asList(118080l, 168480l, 202500l);
         assertEquals(expected, actual);
     }
 }

data/tracks/java/exercises/settings.gradle

@@ -34,6 +34,7 @@ include 'forth'
 include 'gigasecond'
 include 'go-counting'
 include 'grade-school'
+include 'grep'
 include 'hamming'
 include 'hexadecimal'
 include 'hello-world'

data/tracks/ocaml/exercises/anagram/example.ml

@@ -1,6 +1,6 @@
 open Base
 
-let to_sorted_list s = String.to_list s |> List.sort ~cmp:Char.compare
+let to_sorted_list s = String.to_list s |> List.sort ~compare:Char.compare
 
 let anagrams target candidates =
   let target_lc = String.lowercase target in

data/tracks/ocaml/exercises/change/example.ml

@@ -8,7 +8,7 @@ let find_smallest_coins_list_meeting_target (cache: int list option array) (coin
   List.filter coins ~f:(fun x -> x <= target)
   |> List.map ~f:find_coins_meeting_target_minus_coin 
   |> List.filter_map ~f:(Fn.id) 
-  |> List.sort ~cmp:(fun xs ys -> Int.compare (List.length xs) (List.length ys))
+  |> List.sort ~compare:(fun xs ys -> Int.compare (List.length xs) (List.length ys))
   |> List.hd
 
 let make_change ~target ~coins = match target with

data/tracks/ocaml/exercises/custom-set/example.ml

@@ -1,7 +1,6 @@
 module type ELEMENT = sig
     type t
     val compare : t -> t -> int
-    val equal : t -> t -> bool
 end
 
 module Make(El: ELEMENT) = struct
@@ -12,11 +11,13 @@ module Make(El: ELEMENT) = struct
 
     type el = El.t
 
+    let el_equal a b = El.compare a b = 0
+
     let is_empty = function
       | [] -> true
       | _ -> false
 
-    let is_member l n = List.filter (El.equal n) l |> is_empty |> not
+    let is_member l n = List.filter (el_equal n) l |> is_empty |> not
 
     let rec is_subset x y = match (x, y) with
       | ([], []) -> true
@@ -34,7 +35,7 @@ module Make(El: ELEMENT) = struct
       | ([], []) -> true
       | ([], _) -> false
       | (_, []) -> false
-      | ((x::xs), (y::ys)) -> El.equal x y && equal xs ys
+      | ((x::xs), (y::ys)) -> el_equal x y && equal xs ys
 
     let of_list = List.sort_uniq El.compare
 

data/tracks/ocaml/exercises/custom-set/test.ml

@@ -17,7 +17,6 @@ end
 module CSet : EXPECTED = Custom_set.Make(struct
   type t = int
   let compare a b = compare (a mod 10) (b mod 10)
-  let equal a b = compare a b = 0
 end)
 
 let assert_true exp _text_ctxt = assert_equal exp true

data/tracks/ocaml/exercises/dominoes/test.ml

@@ -20,7 +20,7 @@ let tuple_compare (x0, y0) (x1, y1) =
 
 let norm l =
   let norm1 (x, y) = if x > y then (y, x) else (x, y) in
-  List.map ~f:norm1 l |> List.sort ~cmp:tuple_compare
+  List.map ~f:norm1 l |> List.sort ~compare:tuple_compare
 
 let check_chain (input: dominoe list) (chained: dominoe list) =
   assert_equal (norm input) (norm chained) ~printer:dominoes_printer ~msg:"chain doesn't use the same dominoes as the input";

data/tracks/ocaml/exercises/etl/example.ml

@@ -4,4 +4,4 @@ let transform data =
   let assign_value value character = ((Char.lowercase character), value) in
   let assign (value, characters) = List.map ~f:(assign_value value) characters in
   let compare (a, _) (b, _) = Char.compare a b in
-  List.sort ~cmp:compare (List.concat (List.map ~f:assign data))
+  List.sort ~compare:compare (List.concat (List.map ~f:assign data))

data/tracks/ocaml/exercises/grade-school/example.ml

@@ -9,4 +9,4 @@ let add s g school = Map.add_multi ~key:g ~data:s school
 
 let grade g school = Map.find school g |> Option.value ~default:[]
 
-let sorted school = Map.map ~f:(List.sort ~cmp:String.compare) school
+let sorted school = Map.map ~f:(List.sort ~compare:String.compare) school

data/tracks/ocaml/exercises/palindrome-products/example.ml

@@ -31,7 +31,7 @@ let smallest ~min ~max =
       |> Sequence.filter ~f:(fun (n, _) -> is_palindrome n) in
     products
       |> Sequence.to_list
-      |> List.sort ~cmp:(fun (x,_) (y,_) -> Int.compare x y)
+      |> List.sort ~compare:(fun (x,_) (y,_) -> Int.compare x y)
       |> List.group ~break:(fun (x, _) (y, _) -> x <> y)
       |> List.hd
       |> Option.map ~f:to_palindrome_products
@@ -50,7 +50,7 @@ let largest ~min ~max =
       |> Sequence.filter ~f:(fun (n, _) -> is_palindrome n) in
     products
       |> Sequence.to_list
-      |> List.sort ~cmp:(fun (x,_) (y,_) -> Int.compare y x)
+      |> List.sort ~compare:(fun (x,_) (y,_) -> Int.compare y x)
       |> List.group ~break:(fun (x, _) (y, _) -> x <> y)
       |> List.hd
       |> Option.map ~f:to_palindrome_products

data/tracks/ocaml/exercises/prime-factors/example.ml

@@ -20,4 +20,4 @@ and factors_of_loop n =
     done;
     Option.value ~default:[n] !res
 
-let factors_of n = List.sort ~cmp:Int64.compare (factors_of' n)
+let factors_of n = List.sort ~compare:Int64.compare (factors_of' n)

data/tracks/ocaml/exercises/robot-name/test.ml

@@ -55,7 +55,7 @@ let unique_name_tests = [
       then (Set.add repeated n, seen)
       else (repeated, Set.add seen n)
       ) in
-    let first_few_repeats = Array.slice (Set.to_array repeated) 0 (min 20 (Set.length repeated)) in
+    let first_few_repeats = Array.sub (Set.to_array repeated) 0 (min 20 (Set.length repeated)) in
     let failure_message = "first few repeats: " ^ (String.concat_array first_few_repeats ~sep:",") in
     assert_bool failure_message (Set.is_empty repeated)
     );

data/tracks/ocaml/exercises/triangle/example.ml

@@ -1,7 +1,7 @@
 open Base
 
 let sort_sides a b c = 
-  let side = List.nth_exn (List.sort ~cmp:Int.compare [a; b; c]) in
+  let side = List.nth_exn (List.sort ~compare:Int.compare [a; b; c]) in
   (side 0, side 1, side 2)
 
 let is_triangle a b c = 

data/tracks/ocaml/make-exercise.sh

@@ -0,0 +1 @@
+make test-assignment ASSIGNMENT=$1

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

@@ -85,7 +85,7 @@ let run ~(language_config: language_config) ~(templates_folder: string) ~(canoni
 let check_canonical_data canonical_data_folder =
   let ok_count = ref 0 in
   let canonical_data_files = find_canonical_data_files canonical_data_folder in
-  let canonical_data_files = List.sort canonical_data_files ~cmp:(fun (s1, _) (s2, _) -> String.compare s1 s2) in
+  let canonical_data_files = List.sort canonical_data_files ~compare:(fun (s1, _) (s2, _) -> String.compare s1 s2) in
   let total_count = List.length canonical_data_files in
   List.iter canonical_data_files ~f:(fun (slug, text) ->
     match parse_json_text text "cases" with

data/tracks/perl5/exercises/raindrops/.meta/solutions/Raindrops.pm

@@ -1,18 +1,19 @@
-package Raindrops;
+package Raindrops 1;
 use strict;
 use warnings;
+use Exporter 'import';
+our @EXPORT_OK = qw(raindrop);
 
-sub convert {
-   my ($num) = @_;
-
-   my $str = '';
-   $str .= "Pling" if $num / 3 == int($num / 3);
-   $str .= "Plang" if $num / 5 == int($num / 5);
-   $str .= "Plong" if $num / 7 == int($num / 7);
-   return $str if $str;
-
-   return $num;
+sub raindrop {
+  my ($num) = @_;
+  my %sounds = (Pling => 3, Plang => 5, Plong => 7);
+  my $str = '';
+  foreach (qw(Pling Plang Plong)) {
+    if ($num % $sounds{$_} == 0) {
+      $str .= $_;
+    }
+  }
+  return $str || $num;
 }
 
 1;
-

data/tracks/perl5/exercises/raindrops/raindrops.t

@@ -1,123 +1,178 @@
 #!/usr/bin/env perl
 use strict;
 use warnings;
-
-use Test::More;
-use JSON::PP qw(decode_json);
+use JSON::PP;
 use FindBin;
-my $dir;
-BEGIN { $dir = $FindBin::Bin . '/' };
-use lib $dir;
+use lib $FindBin::Bin;
+use Raindrops qw(raindrop);
 
-my $module = 'Raindrops';
+my $exercise = 'Raindrops';
+my $test_version = 1;
+use Test::More tests => 19;
 
-my $cases;
-{
-    local $/ = undef;
-    $cases = decode_json scalar <DATA>;
+my $exercise_version = $exercise->VERSION // 0;
+if ($exercise_version != $test_version) {
+  warn "\nExercise version mismatch. Further tests may fail!"
+    . "\n$exercise is v$exercise_version. "
+    . "Test is v$test_version.\n";
+  BAIL_OUT if $ENV{EXERCISM};
 }
 
-#plan tests => 3 + @$cases;
-#diag explain $cases;
-
-ok -e "${dir}${module}.pm", "missing $module.pm"
-    or BAIL_OUT("You need to create a class called $module.pm with a constructor called convert.");
-
-eval "use $module";
-ok !$@, "Cannot load $module.pm"
-    or BAIL_OUT("Does $module.pm compile?  Does it end with 1; ? ($@)");
-
-can_ok($module, 'convert') or BAIL_OUT("Missing package $module; or missing sub convert()");
+can_ok $exercise, 'import' or BAIL_OUT 'Cannot import subroutines from module';
 
-my $sub = $module->can('convert');
-
-foreach my $c (@$cases) {
-    is $sub->($c->{input}), $c->{expected}, $c->{name}
+my $C_DATA = do { local $/; decode_json(<DATA>); };
+foreach (@{$C_DATA->{cases}}) {
+  is raindrop($_->{input}{number}), $_->{expected}, $_->{description};
 }
 
-done_testing();
-
 __DATA__
-[
-  {
-    "input"    : 1,
-    "expected" : 1,
-    "name"     : "test_1"
-  },
-  {
-    "input"    : 3,
-    "expected" : "Pling",
-    "name"     : "test_3"
-  },
-  {
-    "input"    : 5,
-    "expected" : "Plang",
-    "name"     : "test_5"
-  },
-  {
-    "input"    : 7,
-    "expected" : "Plong",
-    "name"     : "test_7"
-  },
-  {
-    "input"    : 6,
-    "expected" : "Pling",
-    "name"     : "test_6"
-  },
-  {
-    "input"    : 9,
-    "expected" : "Pling",
-    "name"     : "test_9"
-  },
-  {
-    "input"    : 10,
-    "expected" : "Plang",
-    "name"     : "test_10"
-  },
-  {
-    "input"    : 14,
-    "expected" : "Plong",
-    "name"     : "test_14"
-  },
-  {
-    "input"    : 15,
-    "expected" : "PlingPlang",
-    "name"     : "test_15"
-  },
-  {
-    "input"    : 21,
-    "expected" : "PlingPlong",
-    "name"     : "test_21"
-  },
-  {
-    "input"    : 25,
-    "expected" : "Plang",
-    "name"     : "test_25"
-  },
-  {
-    "input"    : 35,
-    "expected" : "PlangPlong",
-    "name"     : "test_35"
-  },
-  {
-    "input"    : 49,
-    "expected" : "Plong",
-    "name"     : "test_49"
-  },
-  {
-    "input"    : 52,
-    "expected" : 52,
-    "name"     : "test_52"
-  },
-  {
-    "input"    : 105,
-    "expected" : "PlingPlangPlong",
-    "name"     : "test_105"
-  },
-  {
-    "input"    : 12121,
-    "expected" : 12121,
-    "name"     : "test_12121"
-  }
-]
-
+{
+  "exercise": "raindrops",
+  "version": "1.1.0",
+  "cases": [
+    {
+      "description": "the sound for 1 is 1",
+      "property": "convert",
+      "input": {
+        "number": 1
+      },
+      "expected": "1"
+    },
+    {
+      "description": "the sound for 3 is Pling",
+      "property": "convert",
+      "input": {
+        "number": 3
+      },
+      "expected": "Pling"
+    },
+    {
+      "description": "the sound for 5 is Plang",
+      "property": "convert",
+      "input": {
+        "number": 5
+      },
+      "expected": "Plang"
+    },
+    {
+      "description": "the sound for 7 is Plong",
+      "property": "convert",
+      "input": {
+        "number": 7
+      },
+      "expected": "Plong"
+    },
+    {
+      "description": "the sound for 6 is Pling as it has a factor 3",
+      "property": "convert",
+      "input": {
+        "number": 6
+      },
+      "expected": "Pling"
+    },
+    {
+      "description": "2 to the power 3 does not make a raindrop sound as 3 is the exponent not the base",
+      "property": "convert",
+      "input": {
+        "number": 8
+      },
+      "expected": "8"
+    },
+    {
+      "description": "the sound for 9 is Pling as it has a factor 3",
+      "property": "convert",
+      "input": {
+        "number": 9
+      },
+      "expected": "Pling"
+    },
+    {
+      "description": "the sound for 10 is Plang as it has a factor 5",
+      "property": "convert",
+      "input": {
+        "number": 10
+      },
+      "expected": "Plang"
+    },
+    {
+      "description": "the sound for 14 is Plong as it has a factor of 7",
+      "property": "convert",
+      "input": {
+        "number": 14
+      },
+      "expected": "Plong"
+    },
+    {
+      "description": "the sound for 15 is PlingPlang as it has factors 3 and 5",
+      "property": "convert",
+      "input": {
+        "number": 15
+      },
+      "expected": "PlingPlang"
+    },
+    {
+      "description": "the sound for 21 is PlingPlong as it has factors 3 and 7",
+      "property": "convert",
+      "input": {
+        "number": 21
+      },
+      "expected": "PlingPlong"
+    },
+    {
+      "description": "the sound for 25 is Plang as it has a factor 5",
+      "property": "convert",
+      "input": {
+        "number": 25
+      },
+      "expected": "Plang"
+    },
+    {
+      "description": "the sound for 27 is Pling as it has a factor 3",
+      "property": "convert",
+      "input": {
+        "number": 27
+      },
+      "expected": "Pling"
+    },
+    {
+      "description": "the sound for 35 is PlangPlong as it has factors 5 and 7",
+      "property": "convert",
+      "input": {
+        "number": 35
+      },
+      "expected": "PlangPlong"
+    },
+    {
+      "description": "the sound for 49 is Plong as it has a factor 7",
+      "property": "convert",
+      "input": {
+        "number": 49
+      },
+      "expected": "Plong"
+    },
+    {
+      "description": "the sound for 52 is 52",
+      "property": "convert",
+      "input": {
+        "number": 52
+      },
+      "expected": "52"
+    },
+    {
+      "description": "the sound for 105 is PlingPlangPlong as it has factors 3, 5 and 7",
+      "property": "convert",
+      "input": {
+        "number": 105
+      },
+      "expected": "PlingPlangPlong"
+    },
+    {
+      "description": "the sound for 3125 is Plang as it has a factor 5",
+      "property": "convert",
+      "input": {
+        "number": 3125
+      },
+      "expected": "Plang"
+    }
+  ]
+}