trackler 2.0.1.0 → 2.0.1.1

data/tracks/ocaml/tools/test-generator/Makefile

@@ -1,11 +1,11 @@
 test: test_gen.native
 	@./all_tests.native
 
-test_gen.native: all_tests.native
-	@ocamlbuild -use-ocamlfind -tag thread -tag short_paths -cflags -strict-sequence -r -pkg core -pkg yojson -pkg ppx_deriving.eq -pkg ppx_deriving.show -Is "src" test_gen.native
+test_gen.native: all_tests.native src/*.ml interfaces/*.mli test/*.ml
+	@ocamlbuild -use-ocamlfind -tag thread -tag short_paths -cflags -strict-sequence -r -pkg core -pkg yojson -pkg ppx_deriving -pkg ppx_deriving.eq -pkg ppx_deriving.show -Is "src,interfaces" test_gen.native
 
-all_tests.native: src/*.ml src/*.mli test/*.ml
-	@ocamlbuild -use-ocamlfind -tag thread -tag short_paths -cflags -strict-sequence -r -pkg core -pkg oUnit -pkg yojson -pkg ppx_deriving.eq -pkg ppx_deriving.show -Is "src,test" all_tests.native
+all_tests.native: src/*.ml test/*.ml
+	@ocamlbuild -use-ocamlfind -tag thread -tag short_paths -cflags -strict-sequence -r -pkg core -pkg oUnit -pkg yojson -pkg ppx_deriving -pkg ppx_deriving.eq -pkg ppx_deriving.show -Is "src,test" all_tests.native
 
 clean:
 	rm -rf _build

data/tracks/ocaml/tools/test-generator/{src → interfaces}/codegen.mli

@@ -6,4 +6,8 @@ type fixup_parameter_function = key: string -> value: parameter -> string
 
 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
+type subst = Subst of string
+
+val subst_to_string : subst -> string
+
+val generate_code : fixup_parameter_function -> edit_parameters_function -> string -> case list -> (subst list, string) Result.t

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

@@ -0,0 +1,7 @@
+open Core.Std
+
+open Model
+
+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/interfaces/template.mli

@@ -0,0 +1,11 @@
+open Core.Std
+
+open Codegen
+
+type t = {start: int; finish: int; file_text: string; template: string}
+
+val fill : int -> int -> template: string -> subst list -> string
+
+val find_template : template_text: string -> (int * int * string) option
+
+val show : t -> string

data/tracks/ocaml/tools/test-generator/interfaces/test_generator.mli

@@ -0,0 +1,3 @@
+open Core.Std
+
+val run : templates_folder: string -> canonical_data_folder: string -> output_folder: string -> unit

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

@@ -6,19 +6,19 @@ 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:";"
+type subst = Subst of string [@@deriving eq, show]
+
+let subst_to_string (Subst s) = s
 
 let replace_key (key: string) (value: string) (target: string): string =
-  String.substr_replace_all target ~pattern:("$" ^ key) ~with_:value
+  String.substr_replace_all ~pattern:("$" ^ key) ~with_:value target
 
-let rec replace_keys (f: fixup_parameter_function) (ed: edit_parameters_function) (s: string) (c: case): string =
+let rec replace_keys (f: fixup_parameter_function) (ed: edit_parameters_function) (s: string) (c: case): subst =
   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
   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)
+  List.fold parameter_strings ~init:(Subst s) ~f:(fun (Subst s) (k,v) -> Subst (replace_key k v s))
 
 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/template.ml

@@ -0,0 +1,24 @@
+open Core.Std
+
+open Codegen
+open Utils
+
+(* start and finish are the lines where the generated code is *)
+type t = {start: int; finish: int; file_text: string; template: string} [@@deriving eq, show]
+
+let find_template ~(template_text: string): t option =
+  let open Option.Monad_infix in
+  let str_contains pattern s = String.substr_index s ~pattern |> Option.is_some in
+  let lines = String.split_lines template_text |> List.to_array in
+  let start_index = find_arrayi lines ~f:(str_contains "(* GENERATED-CODE") |> Option.map ~f:fst in
+  let finish_index = (start_index >>= (fun start -> find_arrayi ~start lines ~f:(str_contains "END GENERATED-CODE *"))) |> Option.map ~f:fst in
+  let template_lines = Option.map2 start_index finish_index (fun s -> Array.slice lines (s+1)) in
+  Option.map2 start_index template_lines ~f:(fun s l -> {start=s; finish=(s + 1 + Array.length l); file_text = template_text; template=String.concat_array l ~sep:"\n"})
+
+let fill (template: t) (substs: subst list): string =
+  let lines = String.split_lines template.file_text |> List.to_array in
+  let before = Array.slice lines 0 template.start in
+  let subst = Array.of_list (List.map ~f:subst_to_string substs) in
+  let after = Array.slice lines (template.finish + 1) (Array.length lines) in
+  let join = String.concat_array ~sep:"\n" in
+  String.concat [join before; join subst; join after] ~sep:"\n"

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

@@ -4,23 +4,7 @@ open Model
 open Utils
 open Codegen
 open Special_cases
-
-let find_template ~(template_text: string): (int * int * string) option =
-  let open Option.Monad_infix in
-  let str_contains pattern s = String.substr_index s ~pattern |> Option.is_some in
-  let lines = String.split_lines template_text |> List.to_array in
-  let start_index = find_arrayi lines ~f:(str_contains "(* GENERATED-CODE") |> Option.map ~f:fst in
-  let finish_index = (start_index >>= (fun start -> find_arrayi ~start lines ~f:(str_contains "END GENERATED-CODE *"))) |> Option.map ~f:fst in
-  let template_lines = Option.map2 start_index finish_index (fun s -> Array.slice lines (s+1)) in
-  Option.map2 start_index template_lines ~f:(fun s l -> (s, s + 1 + Array.length l, String.concat_array l ~sep:"\n"))
-
-let splice_in_filled_in_code (start: int) (finish: int) ~(template: string) (substs: string list): string =
-  let lines = String.split_lines template |> List.to_array in
-  let before = Array.slice lines 0 start in
-  let subst = Array.of_list substs in
-  let after = Array.slice lines (finish + 1) (Array.length lines) in
-  let join = String.concat_array ~sep:"\n" in
-  String.concat [join before; join subst; join after] ~sep:"\n"
+open Template
 
 type content = string
 
@@ -30,23 +14,23 @@ let find_nested_files (name: string) (base: string): (string * content) list =
     |> List.filter ~f:(fun slug -> Sys.file_exists_exn (base ^ "/" ^ slug ^ "/" ^ name))
     |> List.map ~f:(fun slug -> (slug, In_channel.read_all (base ^ "/" ^ slug ^ "/" ^ name)))
 
-let find_templates = find_nested_files "template.ml"
+let find_template_files = find_nested_files "template.ml"
 
 let find_canonical_data_files = find_nested_files "canonical-data.json"
 
-let combine_files (templates: (string * content) list) (canonical_data: (string * content) list): (string * content * content) list =
-  List.filter_map templates ~f:(fun (n,t) -> (List.Assoc.find canonical_data ~equal:String.equal n |> Option.map ~f:(fun c -> (n,t,c))))
+let combine_files (template_files: (string * content) list) (canonical_data_files: (string * content) list): (string * content * content) list =
+  List.filter_map template_files ~f:(fun (n,t) -> (List.Assoc.find canonical_data_files ~equal:String.equal n |> Option.map ~f:(fun c -> (n,t,c))))
 
 let generate_code ~slug ~template_file ~canonical_data_file =
   let template = find_template template_file in
-  let template = Result.of_option template "cannot find a template" in
+  let template = Result.of_option template ("cannot recognize file for " ^ slug ^ " as a template") in
   let cases = parse_json_text canonical_data_file in
   let cases = Result.map_error cases show_error in
   let open Result.Monad_infix in
-  template >>= fun (s,e,template) ->
+  template >>= fun template ->
   cases >>= fun cs ->
-  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 substs = Result.ok_or_failwith @@ generate_code (fixup ~stringify:parameter_to_string ~slug) (edit ~slug) template.template cs in
+  Result.return (fill template substs)
 
 let output_tests (files: (string * content * content) list) (output_folder: string): unit =
   let output_filepath name = output_folder ^ "/" ^ name ^ "/test.ml" in
@@ -56,7 +40,7 @@ let output_tests (files: (string * content * content) list) (output_folder: stri
   List.iter files ~f:output1
 
 let run ~(templates_folder: string) ~(canonical_data_folder: string) ~(output_folder: string) =
-  let templates = find_templates templates_folder in
+  let template_files = find_template_files templates_folder in
   let canonical_data_files = find_canonical_data_files canonical_data_folder in
-  let combined = combine_files templates canonical_data_files in
+  let combined = combine_files template_files canonical_data_files in
   output_tests combined output_folder

data/tracks/ocaml/tools/test-generator/test/all_tests.ml

@@ -4,8 +4,8 @@ open Codegen_test
 open Model_test
 open Parser_test
 open Special_cases_test
-open Test_generator_test
+open Template_test
 open Utils_test
 
 let () =
-  run_test_tt_main ("tests" >:::List.concat [codegen_tests; model_tests; parser_tests; special_cases_tests; test_generator_tests; utils_tests])
+  run_test_tt_main ("tests" >:::List.concat [codegen_tests; model_tests; parser_tests; special_cases_tests; template_tests; utils_tests])

data/tracks/ocaml/tools/test-generator/test/codegen_test.ml

@@ -9,7 +9,7 @@ let fixup ~key ~value = parameter_to_string value
 let edit = Fn.id
 let assert_gen exp cases = assert_equal exp
     ~printer:(fun xs -> "[" ^ (String.concat ~sep:";" xs) ^ "]")
-    (Result.ok_or_failwith @@ generate_code fixup edit leap_template cases)
+    (Result.ok_or_failwith @@ generate_code fixup edit leap_template cases |> List.map ~f:subst_to_string)
 let ae exp cases _test_ctxt = assert_gen exp cases
 
 let codegen_tests = [

data/tracks/ocaml/tools/test-generator/test/sample_template.txt

@@ -0,0 +1,14 @@
+open Core.Std
+open OUnit2
+open Hello_world
+
+let ae exp got _test_ctxt = assert_equal ~printer:String.to_string exp got
+
+let tests = [
+  (* GENERATED-CODE
+code
+     END GENERATED-CODE *)
+]
+
+let () =
+  run_test_tt_main ("Hello World tests" >::: tests)

data/tracks/ocaml/tools/test-generator/test/template_test.ml

@@ -0,0 +1,26 @@
+open Core.Std
+open OUnit2
+open Codegen
+open Template
+
+let printer = Option.value_map ~f:show ~default:"None"
+
+let template_tests = [
+  "if there is no generated code marker in a string then find_template returns None" >:: (fun _ctx ->
+      assert_equal None @@ find_template ~template_text:"some code block"
+    );
+
+  "if there is generated code marker in a string then find_template returns where it is" >:: (fun _ctx ->
+      let template_text = In_channel.read_all "test/sample_template.txt" in
+      assert_equal ~printer (Some {start=7; finish=9; file_text=template_text; template="code"}) @@ find_template ~template_text
+    );
+
+  "fills in lines of a template" >:: (fun _ctx ->
+      let template_text = In_channel.read_all "test/sample_template.txt" in
+      let template = {start=7; finish=9; file_text=template_text;template="code"} in
+      let filled = fill template [Subst "line1"; Subst "line2"] in
+      let pattern = "  (* GENERATED-CODE\ncode\n     END GENERATED-CODE *)" in
+      let expected = (String.substr_replace_all ~pattern ~with_:"line1\nline2" template_text) in
+      assert_equal ~printer:Fn.id expected (filled ^ "\n")
+    );
+]

data/tracks/perl6/exercises/binary/binary.t

@@ -6,7 +6,7 @@ use lib IO::Path.new($?FILE).parent.path;
 plan 10;
 
 BEGIN {
-  my $module = %*ENV{'EXERCISM'} ?? 'Example' !! 'Anagram';
+  my $module = %*ENV{'EXERCISM'} ?? 'Example' !! 'Binary';
   EVAL("use $module")
 };
 

data/tracks/perl6/exercises/raindrops/Example.pm

@@ -1,9 +1,9 @@
 class Raindrops {
-    method convert ($num) {
+    method convert (Int:D $num --> Str:D) {
        my $str = '';
        $str ~= "Pling" if $num % 3 == 0;
        $str ~= "Plang" if $num % 5 == 0;
        $str ~= "Plong" if $num % 7 == 0;
-       return $str ?? $str !! $num;
+       return $str ?? $str !! $num.Str;
     }
 }

data/tracks/perl6/exercises/raindrops/raindrops.t

@@ -3,31 +3,26 @@ use v6;
 use Test;
 use lib IO::Path.new($?FILE).parent.path;
 
-plan 18;
-
 BEGIN {
-  my $module = %*ENV{'EXERCISM'} ?? 'Example' !! 'Raindrops';
-  EVAL("use $module")
-};
-
-pass 'Load module';
-
+  plan 23;
+  eval-lives-ok %*ENV<EXERCISM>.so ?? 'use Example' !! 'use Raindrops', 'Module loaded';
+}
 
 ok Raindrops.can('convert'), 'Class Raindrops has convert method';
 
-is Raindrops.convert(1),      1,                  "test_1";
-is Raindrops.convert(3),      "Pling",            "test_3";
-is Raindrops.convert(5),      "Plang",            "test_5";
-is Raindrops.convert(7),      "Plong",            "test_7";
-is Raindrops.convert(6),      "Pling",            "test_6";
-is Raindrops.convert(9),      "Pling",            "test_9";
-is Raindrops.convert(10),     "Plang",            "test_10";
-is Raindrops.convert(14),     "Plong",            "test_14";
-is Raindrops.convert(15),     "PlingPlang",       "test_15";
-is Raindrops.convert(21),     "PlingPlong",       "test_21";
-is Raindrops.convert(25),     "Plang",            "test_25";
-is Raindrops.convert(35),     "PlangPlong",       "test_35";
-is Raindrops.convert(49),     "Plong",            "test_49";
-is Raindrops.convert(52),     52,                 "test_52";
-is Raindrops.convert(105),    "PlingPlangPlong",  "test_105";
-is Raindrops.convert(12121),  12121,              "test_12121";
+my @ints = 1, 8, 52;
+my @plings = 3, 6, 9, 27;
+my @plangs = 5, 10, 25, 3125;
+my @plongs = 7, 14, 49;
+
+for @ints {
+  is Raindrops.convert($_), $_, "$_ is not a factor of 3, 5 or 7";
+  isa-ok Raindrops.convert($_), Str, "$_ gives a string";
+}
+is Raindrops.convert($_), 'Pling', "$_ is a factor of 3, not 5 or 7" for @plings;
+is Raindrops.convert($_), 'Plang', "$_ is a factor of 5, not 3 or 7" for @plangs;
+is Raindrops.convert($_), 'Plong', "$_ is a factor of 7, not 3 or 5" for @plongs;
+is Raindrops.convert(15), 'PlingPlang', '15 is a factor of 3 and 5, not 7';
+is Raindrops.convert(21), 'PlingPlong', '21 is a factor of 3 and 7, not 5';
+is Raindrops.convert(35), 'PlangPlong', '35 is a factor of 5 and 7, not 3';
+is Raindrops.convert(105), 'PlingPlangPlong', '105 is a factor of 3, 5 and 7';

data/tracks/php/.travis.yml

@@ -3,6 +3,7 @@ language: php
 php:
 - 7.0
 script:
+- make install
 - make style-check
 - make test
 - "./bin/fetch-configlet"

data/tracks/php/Makefile

@@ -12,32 +12,43 @@ FILEEXT := "php"
 EXAMPLE := "example.$(FILEEXT)"
 TSTFILE := "$(ASSIGNMENT)_test.$(FILEEXT)"
 
-# development dependencies
-bin/phpunit.phar:
-	@wget --no-check-certificate https://phar.phpunit.de/phpunit.phar -O $@
-	chmod +x $@
+default:
+	wget --no-check-certificate https://phar.phpunit.de/phpunit.phar -O bin/phpunit.phar
+	chmod +x bin/phpunit.phar
+	@wget --no-check-certificate https://github.com/squizlabs/PHP_CodeSniffer/releases/download/2.0.0a2/phpcs.phar -O bin/phpcs.phar
+	chmod +x bin/phpcs.phar
 
-bin/phpcs.phar:
-	@wget --no-check-certificate https://github.com/squizlabs/PHP_CodeSniffer/releases/download/2.0.0a2/phpcs.phar -O $@
-	chmod +x $@
+help: ## Prints this help
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}'
 
-# single test
-test-assignment: bin/phpunit.phar
+install: ## install development dependencies
+	wget --no-check-certificate https://phar.phpunit.de/phpunit.phar -O bin/phpunit.phar
+	chmod +x bin/phpunit.phar
+
+	@wget --no-check-certificate https://github.com/squizlabs/PHP_CodeSniffer/releases/download/2.0.0a2/phpcs.phar -O bin/phpcs.phar
+	chmod +x bin/phpcs.phar
+
+install-test: ## install test dependency: phpunit.phar 
+	@wget --no-check-certificate https://phar.phpunit.de/phpunit.phar -O bin/phpunit.phar
+	chmod +x bin/phpunit.phar
+
+install-style: ## install style checker dependency: phpcs.phar
+	@wget --no-check-certificate https://phar.phpunit.de/phpunit.phar -O bin/phpcs.phar
+	chmod +x bin/phpcs.phar
+
+test-assignment: bin/phpunit.phar ## run single test using ASSIGNMENTS: test-assignment ASSIGNMENT=wordy
 	@echo "running tests for: $(ASSIGNMENT)"
 	@cat ./exercises/$(ASSIGNMENT)/$(TSTFILE) | sed '/markTestSkipped()/d' > $(OUTDIR)/$(TSTFILE)
 	@cp ./exercises/$(ASSIGNMENT)/$(EXAMPLE) $(OUTDIR)/$(ASSIGNMENT).$(FILEEXT)
 	@bin/phpunit.phar --no-configuration $(OUTDIR)/$(TSTFILE)
 
-# all tests
-test:
+test: ## run all tests
 	@for assignment in $(ASSIGNMENTS); do ASSIGNMENT=$$assignment $(MAKE) -s test-assignment || exit 1; done
 
-# style check single test
-style-check-assignment: bin/phpcs.phar
+style-check-assignment: bin/phpcs.phar ## run style check single test using ASSIGNMENTS: style-check-assignment ASSIGNMENT=wordy
 	@echo "checking $(ASSIGNMENT) against xPHP code standards"
 	@bin/phpcs.phar -sp --standard=phpcs-xphp.xml ./exercises/$(ASSIGNMENT)
 
-# style c heck all tests
-style-check:
+style-check: ## run style check all tests
 	@for assignment in $(ASSIGNMENTS); do ASSIGNMENT=$$assignment $(MAKE) -s style-check-assignment || exit 1; done
 

data/tracks/php/README.md

@@ -4,6 +4,20 @@
 
 Exercism exercises in PHP
 
+## Install Dependencies
+
+### All dependencies
+
+	% make install
+
+### Only tests dependencies
+
+	% make install-test
+
+### Only style-check dependencies
+
+	% make install-style
+
 ## Running Unit Test Suite
 
 ### All Assignments
@@ -24,6 +38,11 @@ Exercism exercises in PHP
 
     % make style-check-assignment ASSIGNMENT=wordy
 
+## Help
+If you need command line help for run make commands
+
+	% make
+
 ## Contributing
 
 - Follow the [PSR-2] coding style (xPHP uses a slightly [modified] version of [PSR-2]).

data/tracks/ruby/README.md

@@ -108,6 +108,16 @@ then additional inputs/outputs should be submitted to the x-common repository.
 Changes to the test suite (style, boilerplate, etc) will probably have to be made to
 `example.tt`.
 
+### Exercise Generators
+
+If you wish to create a new generator, or edit an existing one, the generators currently live in the lib directory and are named `$PROBLEM_cases.rb`.  For example, the hamming generator is `lib/hamming_cases.rb`.  
+
+All generators currently adhere to a common public interface, and must define the following three methods:
+
+- `test_name` - Returns the name of the test (i.e `test_one_equals_one`)
+- `workload` - Returns the main syntax for the test.  This will vary depending on the test generator and its underlying implementation
+- `skipped` - Returns skip syntax (i.e. `skip` or `# skip`)
+
 ## Pull Requests
 
 We welcome pull requests that provide fixes to existing test suites (missing

data/tracks/rust/config.json

@@ -39,6 +39,7 @@
     "wordy",
     "tournament",
     "custom-set",
+    "alphametics",
     "anagram",
     "nucleotide-codons",
     "robot-name",

data/tracks/rust/exercises/alphametics/Cargo-example.toml

@@ -0,0 +1,7 @@
+[package]
+name = "alphametics"
+version = "0.0.0"
+
+[dependencies]
+itertools = "0.5"
+permutohedron = "0.2"

data/tracks/rust/exercises/alphametics/Cargo.lock

@@ -0,0 +1,4 @@
+[root]
+name = "alphametics"
+version = "0.0.0"
+

data/tracks/rust/exercises/alphametics/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "alphametics"
+version = "0.0.0"

data/tracks/rust/exercises/alphametics/example.rs

@@ -0,0 +1,76 @@
+// This is a brute-force solution, use `cargo test --release` for faster testing
+
+extern crate itertools;
+extern crate permutohedron;
+
+use itertools::Itertools;
+use permutohedron::Heap as Permutations;
+
+
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::char;
+
+fn test_equation(puzzle: &str, substitutions: &HashMap<char, u8>) -> bool {
+    // Create a new String with characters changed to numbers
+    let puzzle: String = puzzle.chars()
+        .map(|c| {
+            if let Some(&n) = substitutions.get(&c) {
+                // If the character is in the substitutions, get the number and
+                // convert it to a char
+                char::from_digit(n as u32, 10).unwrap()
+            } else {
+                // Otherwise just copy over the character
+                c
+            }
+        })
+        .collect();
+
+    // Split the puzzle into left and right side
+    let equation: Vec<&str> = puzzle.split("==").collect();
+
+    // Parse the number on the right side
+    let right = equation[1].trim().parse::<u32>().unwrap();
+
+    // Sum the parts on the left side
+    let left: u32 = equation[0].split('+').map(str::trim).map(|n| n.parse::<u32>().unwrap()).sum();
+
+    // Create a String with just the numbers and spaces
+    let just_numbers =
+        puzzle.chars().filter(|c| c.is_digit(10) || c.is_whitespace()).collect::<String>();
+    // Split this into the numbers and check every number's first character
+    let no_leading_zeroes = just_numbers.split_whitespace()
+        .all(|number| number.chars().next().unwrap() != '0');
+
+    // Return true if left and right side is equal and the equation doesnt
+    // contain leading zeroes.
+    left == right && no_leading_zeroes
+}
+
+
+pub fn solve(puzzle: &str) -> Option<HashMap<char, u8>> {
+    // Get unique letters from the puzzle
+    let letters: HashSet<char> =
+        puzzle.chars().filter(|&c| c.is_alphabetic() && c.is_uppercase()).collect();
+    let letters: Vec<char> = letters.into_iter().collect();
+
+    // All available numbers for substitution
+    let numbers: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+    // Iterate every combination with the length of unique letters in the puzzle
+    for combinations in numbers.iter().combinations(letters.len()) {
+        let mut c = combinations;
+        let permutations = Permutations::new(&mut c);
+        // Iterate every permutation of a letter combination
+        for p in permutations {
+            let substitution: HashMap<char, u8> =
+                letters.iter().zip(p).map(|(&c, &n)| (c, n)).collect();
+            if test_equation(puzzle, &substitution) {
+                // We found a good substitution
+                return Some(substitution);
+            }
+        }
+    }
+    // If we tested every combination and did not found a solution then return None
+    None
+}

data/tracks/rust/exercises/alphametics/src/lib.rs

@@ -0,0 +1,5 @@
+use std::collections::HashMap;
+
+pub fn solve(puzzle: &str) -> Option<HashMap<char, u8>> {
+    unimplemented!()
+}

data/tracks/rust/exercises/alphametics/tests/alphametics.rs

@@ -0,0 +1,62 @@
+extern crate alphametics;
+use std::collections::HashMap;
+
+fn assert_alphametic_solution_eq(puzzle: &str, solution: &[(char, u8)]) {
+    let answer = alphametics::solve(puzzle).unwrap();
+    let solution: HashMap<char, u8> = solution.iter().cloned().collect();
+    assert_eq!(answer, solution);
+}
+
+#[test]
+fn test_with_three_letters() {
+    assert_alphametic_solution_eq("I + BB == ILL", &[('I', 1), ('B', 9), ('L', 0)]);
+}
+
+#[test]
+#[ignore]
+fn test_must_have_unique_value_for_each_letter() {
+    let answer = alphametics::solve("A == B");
+    assert_eq!(answer, None);
+}
+
+#[test]
+#[ignore]
+fn test_leading_zero_solution_is_invalid() {
+    let answer = alphametics::solve("ACA + DD == BD");
+    assert_eq!(answer, None);
+}
+
+#[test]
+#[ignore]
+fn test_puzzle_with_four_letters() {
+    assert_alphametic_solution_eq("AS + A == MOM", &[('A', 9), ('S', 2), ('M', 1), ('O', 0)]);
+}
+
+#[test]
+#[ignore]
+fn test_puzzle_with_six_letters() {
+    assert_alphametic_solution_eq("NO + NO + TOO == LATE",
+                &[('N', 7), ('O', 4), ('T', 9), ('L', 1), ('A', 0), ('E', 2)]);
+}
+
+#[test]
+#[ignore]
+fn test_puzzle_with_seven_letters() {
+    assert_alphametic_solution_eq("HE + SEES + THE == LIGHT",
+                &[('E', 4), ('G', 2), ('H', 5), ('I', 0), ('L', 1), ('S', 9), ('T', 7)]);
+}
+
+#[test]
+#[ignore]
+fn test_puzzle_with_eight_letters() {
+    assert_alphametic_solution_eq("SEND + MORE == MONEY",
+                &[('S', 9), ('E', 5), ('N', 6), ('D', 7), ('M', 1), ('O', 0), ('R', 8), ('Y', 2)]);
+}
+
+#[test]
+#[ignore]
+fn test_puzzle_with_ten_letters() {
+    assert_alphametic_solution_eq("AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE",
+                &[('A', 5), ('D', 3), ('E', 4), ('F', 7), ('G', 8), ('N', 0), ('O', 2), ('R', 1),
+                  ('S', 6), ('T', 9)]);
+}

data/tracks/rust/problems.md

@@ -58,6 +58,7 @@ phone-number |  option, format, unwrap_or, iters, match
 wordy | Result, string parsing, operators (optional)
 tournament |  enum, sorting, hashmap, structs
 custom-set |  generic over type, vector, equality, struct
+alphametics | string parsing, combinations, math, external crates (optional)
 
 ## Rust Gets Strange
 

data/tracks/scala/exercises/dominoes/src/test/scala/DominoesSuite.scala

@@ -71,7 +71,7 @@ class DominoesSuite extends FunSuite with Matchers {
 
   private def checkChain(result: List[(Int, Int)], input: List[(Int, Int)]): Unit = {
     def sortDomino(ab: (Int, Int)): (Int, Int) =
-      if (x._1 > x._2) x.swap else x
+      if (ab._1 > ab._2) ab.swap else ab
     def consecutivesShouldMatch(dominoes: List[((Int, Int), Int)]): Unit =
       dominoes.tails foreach {
         case (a@(_,x), i1)::(b@(y,_), i2)::_ =>

data/tracks/swift/Dangerfile

@@ -1,5 +1,3 @@
-message("Thank you for submitting this PR.")
-
 # Ensure a clean commits history
 if git.commits.any? { |c| c.message =~ /^Merge branch '#{github.branch_for_base}'/ }
   fail('Please rebase to get rid of the merge commits in this PR')