trackler 2.0.0.9 → 2.0.0.10

data/tracks/ecmascript/exercises/series/package.json

@@ -18,7 +18,8 @@
     "yargs": "~3.27.0"
   },
   "scripts": {
-    "test": "gulp lint test"
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
   },
   "licenses": [
     "MIT"

data/tracks/ecmascript/exercises/sieve/package.json

@@ -18,7 +18,8 @@
     "yargs": "~3.27.0"
   },
   "scripts": {
-    "test": "gulp lint test"
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
   },
   "licenses": [
     "MIT"

data/tracks/ecmascript/exercises/simple-cipher/package.json

@@ -18,7 +18,8 @@
     "yargs": "~3.27.0"
   },
   "scripts": {
-    "test": "gulp lint test"
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
   },
   "licenses": [
     "MIT"

data/tracks/ecmascript/exercises/space-age/package.json

@@ -18,7 +18,8 @@
     "yargs": "~3.27.0"
   },
   "scripts": {
-    "test": "gulp lint test"
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
   },
   "licenses": [
     "MIT"

data/tracks/ecmascript/exercises/strain/package.json

@@ -18,7 +18,8 @@
     "yargs": "~3.27.0"
   },
   "scripts": {
-    "test": "gulp lint test"
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
   },
   "licenses": [
     "MIT"

data/tracks/ecmascript/exercises/sum-of-multiples/package.json

@@ -18,7 +18,8 @@
     "yargs": "~3.27.0"
   },
   "scripts": {
-    "test": "gulp lint test"
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
   },
   "licenses": [
     "MIT"

data/tracks/ecmascript/exercises/triangle/package.json

@@ -18,7 +18,8 @@
     "yargs": "~3.27.0"
   },
   "scripts": {
-    "test": "gulp lint test"
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
   },
   "licenses": [
     "MIT"

data/tracks/ecmascript/exercises/trinary/package.json

@@ -18,7 +18,8 @@
     "yargs": "~3.27.0"
   },
   "scripts": {
-    "test": "gulp lint test"
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
   },
   "licenses": [
     "MIT"

data/tracks/ecmascript/exercises/two-bucket/package.json

@@ -18,7 +18,8 @@
     "yargs": "~3.27.0"
   },
   "scripts": {
-    "test": "gulp lint test"
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
   },
   "licenses": [
     "MIT"

data/tracks/ecmascript/exercises/word-count/package.json

@@ -18,7 +18,8 @@
     "yargs": "~3.27.0"
   },
   "scripts": {
-    "test": "gulp lint test"
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
   },
   "licenses": [
     "MIT"

data/tracks/ecmascript/exercises/wordy/package.json

@@ -18,7 +18,8 @@
     "yargs": "~3.27.0"
   },
   "scripts": {
-    "test": "gulp lint test"
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
   },
   "licenses": [
     "MIT"

data/tracks/ecmascript/package.json

@@ -18,7 +18,8 @@
     "yargs": "~3.27.0"
   },
   "scripts": {
-    "test": "gulp lint test"
+    "test": "gulp test",
+    "lint-test": "gulp lint test"
   },
   "licenses": [
     "MIT"

data/tracks/go/.travis.yml

@@ -26,7 +26,7 @@ go:
   - tip
 
 # Travis runs in a 64 bit environment but beginning with Go 1.5, building a
-# 32 bit target is as easy as specifying GOARCH.  We test both to accomodate
+# 32 bit target is as easy as specifying GOARCH.  We test both to accommodate
 # users that might be running 32 bit environments and make sure our code
 # works for them.
 #

data/tracks/go/docs/LEARNING.md

@@ -7,3 +7,4 @@ Exercism provides exercises and feedback but can be difficult to jump into for t
 * [Go Standard Library](http://golang.org/pkg/)
 * [Go Resources](http://golang.org/help)
 * [StackOverflow](http://stackoverflow.com/questions/tagged/go)
+* [Awesome Go](https://github.com/avelino/awesome-go): [E-Books](https://github.com/avelino/awesome-go#e-books) and [Tutorials](https://github.com/avelino/awesome-go#tutorials)

data/tracks/java/config.json

@@ -39,6 +39,7 @@
     "luhn",
     "pig-latin",
     "simple-linked-list",
+    "sum-of-multiples",
     "linked-list",
     "nth-prime",
     "pascals-triangle",
@@ -225,6 +226,11 @@
       "difficulty": 1,
       "topics": []
     },
+    {
+      "slug": "sum-of-multiples",
+      "difficulty": 1,
+      "topics": []
+    },
     {
       "slug": "linked-list",
       "difficulty": 1,

data/tracks/java/exercises/settings.gradle

@@ -37,6 +37,7 @@ include 'series'
 include 'sieve'
 include 'simple-cipher'
 include 'simple-linked-list'
+include 'sum-of-multiples'
 include 'space-age'
 include 'strain'
 include 'triangle'

data/tracks/java/exercises/sum-of-multiples/build.gradle

@@ -0,0 +1,17 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

data/tracks/java/exercises/sum-of-multiples/src/example/java/SumOfMultiples.java

@@ -0,0 +1,27 @@
+import java.util.Arrays;
+public class SumOfMultiples {
+    
+    
+    public int Sum(int number, int[] set) {
+        
+        int sum = 0;
+        int count = 0;
+        
+        for (int i = 1; i < number; i++) {
+            
+            for (int j = 0; j < set.length; j++) {
+                if (i % set[j] == 0) {
+                    count++;
+                }
+            }
+            
+            if (count > 0) {
+                sum = sum + i;
+                count = 0;
+            }
+        }
+        
+        return sum;
+    }
+    
+}

data/tracks/java/exercises/sum-of-multiples/src/main/java/SumOfMultiples.java

@@ -0,0 +1,4 @@
+import java.util.Arrays;
+public class SumOfMultiples {
+    
+}

data/tracks/java/exercises/sum-of-multiples/src/test/SumOfMultiplesTest.java

@@ -0,0 +1,187 @@
+import static org.junit.Assert.*;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class SumOfMultiplesTest {
+    
+    
+    @Test
+    public void testSumOfMultiplesOf3and4UpToOne() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            3,
+            5
+        };
+        int output = mySum.Sum(1, set);
+        assertEquals(0, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf3and5UpToFour() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            3,
+            5
+        };
+        int output = mySum.Sum(4, set);
+        assertEquals(3, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf3and5UpToTen() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            3,
+            5
+        };
+        int output = mySum.Sum(10, set);
+        assertEquals(23, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf3and5UpToOneHundred() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            3,
+            5
+        };
+        int output = mySum.Sum(100, set);
+        assertEquals(2318, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf3and5UpToOneThousand() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            3,
+            5
+        };
+        int output = mySum.Sum(1000, set);
+        assertEquals(233168, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf7and13and17UpToTwenty() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            7,
+            13,
+            17
+        };
+        int output = mySum.Sum(20, set);
+        assertEquals(51, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf4and6UpToFifteen() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            4,
+            6
+        };
+        int output = mySum.Sum(15, set);
+        assertEquals(30, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf5and6and8UpToOneHundredFifty() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            5,
+            6,
+            8
+        };
+        int output = mySum.Sum(150, set);
+        assertEquals(4419, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf5and25UpToTwoHundredSeventyFive() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            5,
+            25
+        };
+        int output = mySum.Sum(51, set);
+        assertEquals(275, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf43and47UpToTenThousand() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            43,
+            47
+        };
+        int output = mySum.Sum(10000, set);
+        assertEquals(2203160, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOfOneUpToOneHundred() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            1
+        };
+        int output = mySum.Sum(100, set);
+        assertEquals(4950, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOfNoneUpToTenThousand() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {};
+        int output = mySum.Sum(10000, set);
+        assertEquals(0, output);
+        
+    }
+    
+    
+    
+}

data/tracks/ocaml/exercises/word-count/example.ml

@@ -1,22 +1,17 @@
 open Core.Std
 
-(* Get a list of all the words in the string.
- *
- * The list is in reverse order (more efficient to construct).
- *
- * This uses manual string slicing to avoid depending on any regex package
- * and because regexes are best avoided for simple tasks.
-*)
-let words (s: string): string list =
-  let f i ((osi, l) as acc) c = match (osi, c) with
-    | (None, c) when Char.is_alphanum c          -> (Some i, l)
-    | (Some si, c) when not (Char.is_alphanum c) -> (None, String.slice s si i :: l)
-    | _                                          -> acc
-  in
-  match String.foldi ~init:(None, []) ~f s with
-  | (None, l)    -> l
-  | (Some si, l) -> String.drop_prefix s si :: l
+module SMap = String.Map
 
-let word_count s = words s
-                   |> List.map ~f:(fun x -> String.lowercase x, 1)
-                   |> String.Map.of_alist_fold ~init:0 ~f:(+)
+let add_to_map wcs w =
+  SMap.update wcs w ~f:(fun k -> Option.value_map k ~default:1 ~f:((+) 1))
+
+let normalize = function
+  | ch when Char.is_alphanum ch || ch = '\'' -> Char.lowercase ch
+  | _ -> ' '
+
+let word_count s =
+  let s = String.substr_replace_all s ~pattern:" \'" ~with_:" " in
+  let s = String.substr_replace_all s ~pattern:"\' " ~with_:" " in
+  let s = String.map s ~f:normalize in
+  let split = List.filter (String.split s ~on:' ') ~f:(Fn.non String.is_empty) in
+  List.fold ~init:SMap.empty ~f:add_to_map split

data/tracks/ocaml/exercises/word-count/test.ml

@@ -8,23 +8,38 @@ let ae exp got _test_ctxt =
   let printer m = SMap.sexp_of_t Int.sexp_of_t m |> Sexp.to_string_hum ~indent:1 in
   assert_equal (SMap.of_alist_exn exp) got ~cmp:(SMap.equal (=)) ~printer
 
-let tests =
-  ["one word">::
-     ae [("word", 1)] (word_count "word");
-   "one of each">::
-     ae [("one", 1); ("of", 1); ("each", 1)] (word_count "one of each");
-   "multiple occurences">::
-     ae [("one", 1); ("fish", 4); ("two", 1); ("red", 1); ("blue", 1)]
-       (word_count "one fish two fish red fish blue fish");
-   "ignore punctuation">::
-     ae [("car", 1); ("carpet", 1); ("as", 1); ("java", 1); ("javascript", 1)]
-       (word_count "car : carpet@as'java : javascript!!&@$%^&");
-   "include numbers">::
-     ae [("testing", 2); ("1", 1); ("2", 1)]
-       (word_count "testing, 1, 2 testing");
-   "normalize case">::
-     ae [("go", 3)] (word_count "go Go GO");
-  ]
+let tests = [
+   "count one word" >::
+      ae [("word", 1)]
+         (word_count "word");
+   "count one of each word" >::
+      ae [("one", 1); ("of", 1); ("each", 1)]
+         (word_count "one of each");
+   "multiple occurrences of a word" >::
+      ae [("one", 1); ("fish", 4); ("two", 1); ("red", 1); ("blue", 1)]
+         (word_count "one fish two fish red fish blue fish");
+   "handles cramped lists" >::
+      ae [("one", 1); ("two", 1); ("three", 1)]
+         (word_count "one,two,three");
+   "handles expanded lists" >::
+      ae [("one", 1); ("two", 1); ("three", 1)]
+         (word_count "one,\ntwo,\nthree");
+   "ignore punctuation" >::
+      ae [("car", 1); ("carpet", 1); ("as", 1); ("java", 1); ("javascript", 1)]
+         (word_count "car: carpet as java: javascript!!&@$%^&");
+   "include numbers" >::
+      ae [("testing", 2); ("1", 1); ("2", 1)]
+         (word_count "testing, 1, 2 testing");
+   "normalize case" >::
+      ae [("go", 3); ("stop", 2)]
+         (word_count "go Go GO Stop stop");
+   "with apostrophes" >::
+      ae [("first", 1); ("don't", 2); ("laugh", 1); ("then", 1); ("cry", 1)]
+         (word_count "First: don't laugh. Then: don't cry.");
+   "with_quotations" >::
+      ae [("joe", 1); ("can't", 1); ("tell", 1); ("between", 1); ("large", 2); ("and", 1)]
+         (word_count "Joe can't tell between 'large' and large.");
+]
 
 let () =
-  run_test_tt_main ("word_count tests" >::: tests)
+  run_test_tt_main ("word_count tests" >::: tests)

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

@@ -2,16 +2,23 @@ open Core.Std
 
 open Model
 
-type fixup_function = key: string -> value: parameter -> string
+type fixup_parameter_function = key: string -> value: parameter -> string
+
+type edit_parameters_function = (string * string) list -> (string * string) list
+
+let parameters_to_string pp: string =
+  List.map ~f:(fun (k,v) -> "(" ^ k ^ "," ^ v ^ ")") pp
+  |> String.concat ~sep:";"
 
 let replace_key (key: string) (value: string) (target: string): string =
   String.substr_replace_all target ~pattern:("$" ^ key) ~with_:value
 
-let rec replace_keys (f: fixup_function) (s: string) (c: case): string =
-  let s = replace_key "name" c.name s in
+let rec replace_keys (f: fixup_parameter_function) (ed: edit_parameters_function) (s: string) (c: case): string =
+  let s = replace_key "description" c.description s in
   let expected = f ~key:"expected" ~value:c.expected in
   let s = replace_key "expected" expected s in
-  List.fold c.parameters ~init:s ~f:(fun s (k,v) -> replace_key k (parameter_to_string v) s)
+  let parameter_strings = ed @@ List.map ~f:(fun (k,p) -> (k,parameter_to_string p)) c.parameters in
+  List.fold parameter_strings ~init:s ~f:(fun s (k,v) -> replace_key k v s)
 
-let generate_code (f: fixup_function) template cases =
-  Ok (List.map cases ~f:(replace_keys f template))
+let generate_code (f: fixup_parameter_function) (ed: edit_parameters_function) template cases =
+  Ok (List.map cases ~f:(replace_keys f ed template))

data/tracks/ocaml/tools/test-generator/src/codegen.mli

@@ -2,6 +2,8 @@ open Core.Std
 
 open Model
 
-type fixup_function = key: string -> value: parameter -> string
+type fixup_parameter_function = key: string -> value: parameter -> string
 
-val generate_code : fixup_function -> string -> case list -> (string list, string) Result.t
+type edit_parameters_function = (string * string) list -> (string * string) list
+
+val generate_code : fixup_parameter_function -> edit_parameters_function -> string -> case list -> (string list, string) Result.t

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

@@ -13,7 +13,7 @@ type parameter =
 type 'a elements = (string * 'a) list [@@deriving eq, show]
 
 type case = {
-  name: string;
+  description: string;
   parameters: parameter elements;
   expected: parameter;
 } [@@deriving eq, show]

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

@@ -34,7 +34,7 @@ let parse_case_assoc (parameters: (string * json) list): (case, error) Result.t
   to_string_note BadDescription >>= fun description ->
   find "expected" BadExpected >>= fun expectedJson ->
   to_parameter expectedJson |> Result.of_option ~error:BadExpected >>= fun expected ->
-  Ok {name = description; parameters = parse_parameters test_parameters; expected = expected}
+  Ok {description = description; parameters = parse_parameters test_parameters; expected = expected}
 
 let parse_case (s: json): (case, error) Result.t = match s with
   | `Assoc assoc -> parse_case_assoc assoc

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

@@ -7,6 +7,25 @@ let optional_int ~(none: int) = function
   | Int n -> "(Some " ^ Int.to_string n ^ ")"
   | _ -> failwith "can't handle non-int parameter"
 
+let default_value ~(key: string) ~(value: string) (parameters: (string * string) list): (string * string) list =
+  if List.exists ~f:(fun (k, _) -> k = key) parameters
+  then parameters
+  else (key, value) :: parameters
+
+let optional_string ~(f: string -> bool) (parameters: (string * string) list): (string * string) list =
+  let replace parameter =
+    let (k, v) = parameter in
+    if f k
+    then (k, "(Some \"" ^ v ^ "\")")
+    else parameter in
+  List.map ~f:replace parameters
+
 let fixup ~(stringify: parameter -> string) ~(slug: string) ~(key: string) ~(value: parameter) = match (slug, key) with
   | ("hamming", "expected") -> optional_int (-1) value
   | _ -> stringify value
+
+let edit ~(slug: string) (parameters: (string * string) list) = match (slug, parameters) with
+  | ("hello-world", ps) -> default_value ~key:"name" ~value:"None"
+    @@ optional_string ~f:(fun _x -> true)
+    @@ parameters
+  | (_, ps) -> ps

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

@@ -2,6 +2,12 @@ open Core.Std
 
 open Model
 
+val default_value : key: string -> value: string -> (string * string) list -> (string * string) list
+
 val optional_int : none: int -> parameter -> string
 
+val optional_string : f: (string -> bool) -> (string * string) list -> (string * string) list
+
 val fixup : stringify:(parameter -> string) -> slug:string -> key:string -> value:parameter -> string
+
+val edit : slug: string -> (string * string) list -> (string * string) list

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

@@ -45,13 +45,13 @@ let generate_code ~slug ~template_file ~canonical_data_file =
   let open Result.Monad_infix in
   template >>= fun (s,e,template) ->
   cases >>= fun cs ->
-  let Ok substs = generate_code (fixup ~stringify:parameter_to_string ~slug) template cs in
+  let substs = Result.ok_or_failwith @@ generate_code (fixup ~stringify:parameter_to_string ~slug) (edit ~slug) template cs in
   Result.return (splice_in_filled_in_code s e ~template:template_file substs)
 
 let output_tests (files: (string * content * content) list) (output_folder: string): unit =
   let output_filepath name = output_folder ^ "/" ^ name ^ "/test.ml" in
   let output1 (slug,t,c) =
-    let Ok code = generate_code slug t c in
+    let code = Result.ok_or_failwith @@ generate_code slug t c in
     Out_channel.write_all (output_filepath slug) code in
   List.iter files ~f:output1
 

data/tracks/ocaml/tools/test-generator/templates/anagram/template.ml

@@ -8,7 +8,7 @@ let ae exp got _test_ctxt =
 
 let tests = [
 (* GENERATED-CODE
-  "$name" >::
+  "$description" >::
     ae $expected (anagrams "$subject" $candidates);
    END GENERATED-CODE *)
 ]

data/tracks/ocaml/tools/test-generator/templates/bob/template.ml

@@ -6,7 +6,7 @@ let ae exp got _test_ctxt = assert_equal ~printer:String.to_string exp got
 
 let tests = [
 (* GENERATED-CODE
-   "$name" >::
+   "$description" >::
       ae "$expected" (response_for "$input");
    END GENERATED-CODE *)
 ]

data/tracks/ocaml/tools/test-generator/templates/hamming/template.ml

@@ -21,7 +21,7 @@ let hamdist a b = Hamming.hamming_distance (dna_of_string a) (dna_of_string b)
 
 let tests = [
 (* GENERATED-CODE
-   "$name" >::
+   "$description" >::
       ae $expected (hamdist "$strand1" "$strand2");
    END GENERATED-CODE *)
 ]