trackler 1.0.1.0 → 1.0.1.1

data/tracks/ocaml/exercises/etl/Makefile

@@ -0,0 +1,11 @@
+test: test.native
+	@./test.native
+
+test.native: *.ml *.mli
+	@corebuild -r -quiet -pkg oUnit test.native
+
+clean:
+	rm -rf _build
+	rm -f test.native
+
+.PHONY: clean

data/tracks/ocaml/exercises/etl/etl.mli

@@ -0,0 +1,2 @@
+(* Transform legacy Scrabble data into shiny new Scrabble data *)
+val transform: (int * char list) list -> (char * int) list

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

@@ -0,0 +1,7 @@
+open Core.Std
+
+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 compare (List.concat (List.map ~f:assign data))

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

@@ -0,0 +1,35 @@
+open Core.Std
+open OUnit2
+open Etl
+
+
+let ae exp got _test_ctxt =
+  let sexpr_of l = List.sexp_of_t (Tuple2.sexp_of_t Char.sexp_of_t Int.sexp_of_t) l in
+  let printer l = Sexp.to_string (sexpr_of l) in
+  assert_equal exp got ~printer
+
+let tests =
+  ["transform one character">::
+   ae [('a', 1)] (transform [(1,['A'])]);
+   "transform multiple characters">::
+   ae [('a', 1);('e', 1);('i', 1);('o', 1);('u', 1)] (transform [(1, ['A';'E';'I';'O';'U'])]);
+   "transform multiple values">::
+   ae [('a',1);('d',2);('e',1);('g',2);('i',1);('o',1);('u',1)] (transform [(1, ['A';'E';'I';'O';'U']);
+                                                                            (2, ['D';'G'])]);
+   "transform full dataset">::
+   ae [('a',1);('b',3);('c',3);('d',2);('e',1);
+       ('f',4);('g',2);('h',4);('i',1);('j',8);
+       ('k',5);('l',1);('m',3);('n',1);('o',1);
+       ('p',3);('q',10);('r',1);('s',1);('t',1);
+       ('u',1);('v',4);('w',4);('x',8);('y',4);
+       ('z',10)] (transform [(1,['A';'E';'I';'O';'U';'L';'N';'R';'S';'T']);
+                            (2,['D';'G']);
+                            (3,['B';'C';'M';'P']);
+                            (4,['F';'H';'V';'W';'Y']);
+                            (5,['K']);
+                            (8,['J';'X']);
+                            (10,['Q';'Z'])]);
+  ]
+
+let () =
+  run_test_tt_main ("etl tests" >::: tests)

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

@@ -2,7 +2,7 @@ open Core.Std
 open OUnit2
 open Raindrops
 
-let ae exp got _test_ctxt = assert_equal exp got
+let ae exp got _test_ctxt = assert_equal ~printer:Fn.id exp got
 
 let tests =
   [

data/tracks/php/config.json

@@ -33,7 +33,8 @@
     "binary",
     "braket-push",
     "accumulate",
-    "variable-length-quantity"
+    "variable-length-quantity",
+    "acronym"
   ],
   "deprecated": [
 
@@ -195,6 +196,11 @@
     "slug": "variable-length-quantity",
     "difficulty": 1,
     "topics": []
+  },
+  {
+    "slug": "acronym",
+    "difficulty": 1,
+    "topics": []
   }
 ]
 }

data/tracks/php/exercises/acronym/acronym_test.php

@@ -0,0 +1,56 @@
+<?php
+
+require_once 'acronym.php';
+
+class AcronymTest extends PHPUnit_Framework_TestCase
+{
+    public function testBasicTitleCase()
+    {
+        $this->assertEquals('PNG', acronym('Portable Network Graphics'));
+    }
+
+    public function testLowerCaseWord()
+    {
+        $this->markTestSkipped();
+
+        $this->assertEquals('ROR', acronym('Ruby on Rails'));
+    }
+
+    public function testCamelCase()
+    {
+        $this->markTestSkipped();
+
+        $this->assertEquals('HTML', acronym('HyperText Markup Language'));
+    }
+
+    public function testAllCapsWords()
+    {
+        $this->markTestSkipped();
+
+        $this->assertEquals('PHP', acronym('PHP: Hypertext Preprocessor'));
+    }
+
+    public function testHyphenated()
+    {
+        $this->markTestSkipped();
+
+        $this->assertEquals('CMOS', acronym('Complementary metal-oxide semiconductor'));
+    }
+
+    // Additional points for making the following tests pass
+
+    public function testOneWordIsNotAbbreviated()
+    {
+        $this->markTestSkipped();
+
+        $this->assertEmpty(acronym('Word'));
+    }
+
+    public function testUnicode()
+    {
+        $this->markTestSkipped();
+
+        $phrase = 'Специализированная процессорная часть';
+        $this->assertEquals('СПЧ', acronym($phrase));
+    }
+}

data/tracks/php/exercises/acronym/example.php

@@ -0,0 +1,20 @@
+<?php
+
+/**
+ * Abbreviates a phrase.
+ *
+ * @param string $phrase
+ * @return string
+ */
+function acronym($phrase)
+{
+    $matches = preg_match_all('/\p{Lu}+\p{Ll}*|\p{Ll}+/u', $phrase, $words);
+
+    if ($matches === false || $matches < 2) {
+        return '';
+    }
+
+    return array_reduce($words[0], function ($acronym, $word) {
+        return $acronym.mb_strtoupper(mb_substr($word, 0, 1));
+    });
+}

data/tracks/racket/config.json

@@ -3,28 +3,115 @@
   "language": "Racket",
   "repository": "https://github.com/exercism/xracket",
   "active": true,
-  "problems": [
-    "hello-world",
-    "grains",
-    "leap",
-    "difference-of-squares",
-    "perfect-numbers",
-    "gigasecond",
-    "bob",
-    "hamming",
-    "scrabble-score",
-    "roman-numerals",
-    "anagram",
-    "rna-transcription",
-    "etl",
-    "word-count",
-    "phone-number",
-    "nucleotide-count",
-    "raindrops",
-    "grep",
-    "say",
-    "allergies",
-    "list-ops"
+  "exercises": [
+    {
+      "difficulty": 1,
+      "slug": "hello-world",
+      "topics": [
+        "optional values",
+        "text formatting"
+      ]
+    },
+    {
+      "difficulty": 1,
+      "slug": "grains",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "leap",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "difference-of-squares",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "perfect-numbers",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "gigasecond",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "bob",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "hamming",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "scrabble-score",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "roman-numerals",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "anagram",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "rna-transcription",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "etl",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "word-count",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "phone-number",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "nucleotide-count",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "raindrops",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "grep",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "say",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "allergies",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "list-ops",
+      "topics": []
+    }
   ],
   "deprecated": [
     "accumulate"

data/tracks/ruby/README.md

@@ -89,7 +89,7 @@ tree -L 1 ~/code/exercism
 1. `xruby/$PROBLEM/example.tt` - the Erb template for the test file, `$PROBLEM_test.rb`.
 1. `x-common/$PROBLEM.json` - the shared inputs and outputs for the problem.
 1. `lib/$PROBLEM.rb` - the logic for turning the data into tests.
-1. `xruby/bin/generate-$PROBLEM` - the command to actually generate the test suite.
+1. `xruby/bin/generate $PROBLEM` - the command to actually generate the test suite.
 1. `.version` - used to keep track of the version of the test files as the data changes.
 
 Additionally, there is some common generator logic in `lib/generator.rb`.
@@ -98,7 +98,7 @@ For example, take a look at the `hamming.json` file in the x-common repository,
 as the following files in the xruby repository:
 
 1. `hamming/example.tt`
-1. `bin/generate-hamming`
+1. `bin/generate hamming`
 1. `lib/hamming.rb`
 1. `lib/generator.rb`
 
@@ -166,4 +166,4 @@ The MIT License (MIT)
 Copyright (c) 2014 Katrina Owen, _@kytrinyx.com
 
 ## Ruby icon
-The Ruby icon is the Vienna.rb logo, and is used with permission. Thanks Floor Dress :)
+The Ruby icon is the Vienna.rb logo, and is used with permission. Thanks Floor Dress :)

data/tracks/ruby/bin/generate

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+exercise = ARGV[0]
+cases = "#{exercise.tr('-','_')}_cases"
+
+require_relative '../lib/helper'
+require 'generator'
+begin
+  require "#{cases}"
+rescue LoadError
+  puts "A generator does not currently exist for #{exercise}!"
+  exit(1)
+end
+
+klass = Object.const_get(cases.split('_').map(&:capitalize).join)
+Generator.new(exercise, klass).generate

data/tracks/ruby/exercises/alphametics/.version

@@ -1 +1 @@
-2
+3

data/tracks/ruby/exercises/alphametics/alphametics_test.rb

@@ -4,7 +4,7 @@ require 'minitest/autorun'
 require_relative 'alphametics'
 
 # Test data version:
-# 0b81bdb
+# 8d8589f
 class AlphameticsTest < Minitest::Test
   def test_solve_short_puzzle
     # skip
@@ -26,26 +26,6 @@ class AlphameticsTest < Minitest::Test
   #   assert_equal(expect, actual)
   # end
 
-  def test_solve_puzzle_with_multiplication
-    skip
-    expect = {
-      'I' => 8, 'F' => 2, 'D' => 3, 'R' => 9,
-      'O' => 1
-    }
-    actual = Alphametics.new.solve('IF * DR == DORI')
-    assert_equal(expect, actual)
-  end
-
-  def test_solve_puzzle_with_exponents
-    skip
-    expect = {
-      'P' => 9, 'I' => 6, 'R' => 7, 'A' => 4,
-      'E' => 0
-    }
-    actual = Alphametics.new.solve('PI * R ^ 2 == AREA')
-    assert_equal(expect, actual)
-  end
-
   def test_solution_must_have_unique_value_for_each_letter
     skip
     expect = nil
@@ -60,6 +40,28 @@ class AlphameticsTest < Minitest::Test
     assert_equal(expect, actual)
   end
 
+  def test_solve_puzzle_with_four_words
+    skip
+    expect = {
+      'E' => 4, 'G' => 2, 'H' => 5, 'I' => 0,
+      'L' => 1, 'S' => 9, 'T' => 7
+    }
+    actual = Alphametics.new.solve('HE + SEES + THE == LIGHT')
+    assert_equal(expect, actual)
+  end
+
+  # This test has been commented out due its long runtime.
+  # def test_solve_puzzle_with_many_words
+  #   skip
+  #   expect = {
+  #     'A' => 5, 'D' => 3, 'E' => 4, 'F' => 7,
+  #     'G' => 8, 'N' => 0, 'O' => 2, 'R' => 1,
+  #     'S' => 6, 'T' => 9
+  #   }
+  #   actual = Alphametics.new.solve('AND + A + STRONG + OFFENSE + AS + A + GOOD = DEFENSE')
+  #   assert_equal(expect, actual)
+  # end
+
   # Problems in exercism evolve over time, as we find better ways to ask
   # questions.
   # The version number refers to the version of the problem you solved,
@@ -79,6 +81,6 @@ class AlphameticsTest < Minitest::Test
 
   def test_bookkeeping
     skip
-    assert_equal 2, BookKeeping::VERSION
+    assert_equal 3, BookKeeping::VERSION
   end
 end

data/tracks/ruby/exercises/alphametics/example.rb

@@ -1,5 +1,5 @@
 module BookKeeping
-  VERSION = 2
+  VERSION = 3
 end
 
 class Alphametics

data/tracks/ruby/lib/bracket_push_cases.rb

@@ -1,4 +1,4 @@
-class BracketsCase < OpenStruct
+class BracketPushCase < OpenStruct
   def name
     'test_%s' % description.gsub(/[ -]/, '_')
   end
@@ -34,8 +34,8 @@ class BracketsCase < OpenStruct
   end
 end
 
-BracketsCases = proc do |data|
+BracketPushCases = proc do |data|
   JSON.parse(data)['cases'].map.with_index do |row, i|
-    BracketsCase.new(row.merge('index' => i))
+    BracketPushCase.new(row.merge('index' => i))
   end
 end

data/tracks/ruby/lib/{raindrop_cases.rb → raindrops_cases.rb}

@@ -12,7 +12,7 @@ class RaindropsCase < OpenStruct
   end
 end
 
-RaindropCases = proc do |data|
+RaindropsCases = proc do |data|
   JSON.parse(data)['cases'].map.with_index do |row, i|
     RaindropsCase.new(row.merge('index' => i))
   end

data/tracks/rust/config.json

@@ -17,6 +17,7 @@
     "pangram",
     "nucleotide-count",
     "word-count",
+    "atbash-cipher",
     "etl",
     "acronym",
     "sieve",

data/tracks/rust/exercises/atbash-cipher/Cargo.lock

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

data/tracks/rust/exercises/atbash-cipher/Cargo.toml

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

data/tracks/rust/exercises/atbash-cipher/example.rs

@@ -0,0 +1,36 @@
+use std::ascii::AsciiExt;
+
+fn ascii(ch: char) -> u8 {
+    ch as u8
+}
+
+fn get_transpose(ch: char) -> char {
+    if ch.is_digit(10) {
+        ch
+    } else {
+        (ascii('z') - ascii(ch) + ascii('a')) as char
+    }
+}
+
+pub fn encode(plaintext: &str) -> String {
+    plaintext
+    .to_lowercase()
+    .chars()
+    .filter(|&ch| ch.is_ascii())
+    .filter(|&ch| ch.is_alphanumeric())
+    .map(|ch| get_transpose(ch))
+    .collect::<Vec<char>>()
+    .chunks(5)
+    .map(|slice| slice.iter().cloned().collect::<String>())
+    .collect::<Vec<String>>()
+    .join(" ")
+}
+
+pub fn decode(ciphertext: &str) -> String {
+    ciphertext
+    .split::<char>(' ')
+    .collect::<String>()
+    .chars()
+    .map(|ch| get_transpose(ch))
+    .collect::<String>()
+}

data/tracks/rust/exercises/atbash-cipher/tests/atbash-cipher.rs

@@ -0,0 +1,82 @@
+extern crate atbash_cipher as cipher;
+
+#[test]
+fn test_encode_yes() {
+    assert_eq!("bvh", cipher::encode("yes"));
+}
+
+#[test]
+#[ignore]
+fn test_encode_no() {
+    assert_eq!("ml", cipher::encode("no"));
+}
+
+#[test]
+#[ignore]
+fn test_encode_omg() {
+    assert_eq!("lnt", cipher::encode("OMG"));
+}
+
+#[test]
+#[ignore]
+fn test_encode_spaces() {
+    assert_eq!("lnt", cipher::encode("O M G"));
+}
+
+#[test]
+#[ignore]
+fn test_encode_mindblowingly() {
+    assert_eq!("nrmwy oldrm tob", cipher::encode("mindblowingly"));
+}
+
+#[test]
+#[ignore]
+fn test_encode_numbers() {
+    assert_eq!("gvhgr mt123 gvhgr mt", cipher::encode("Testing,1 2 3, testing."));
+}
+
+#[test]
+#[ignore]
+fn test_encode_deep_thought() {
+    assert_eq!("gifgs rhurx grlm", cipher::encode("Truth is fiction."));
+}
+
+#[test]
+#[ignore]
+fn test_encode_all_the_letters() {
+    assert_eq!("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt",
+        cipher::encode("The quick brown fox jumps over the lazy dog."));
+}
+
+#[test]
+#[ignore]
+fn test_encode_ignores_non_ascii() {
+    assert_eq!("mlmzh xrrrt mlivw", cipher::encode("non ascii éignored"));
+}
+
+
+#[test]
+#[ignore]
+fn test_decode_exercism() {
+    assert_eq!("exercism", cipher::decode("vcvix rhn"));
+}
+
+#[test]
+#[ignore]
+fn test_decode_a_sentence() {
+    assert_eq!("anobstacleisoftenasteppingstone",
+        cipher::decode("zmlyh gzxov rhlug vmzhg vkkrm thglm v"));
+}
+
+#[test]
+#[ignore]
+fn test_decode_numbers() {
+    assert_eq!("testing123testing", cipher::decode("gvhgr mt123 gvhgr mt"));
+}
+
+#[test]
+#[ignore]
+fn test_decode_all_the_letters() {
+    assert_eq!("thequickbrownfoxjumpsoverthelazydog",
+        cipher::decode("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"));
+}

data/tracks/rust/problems.md

@@ -36,6 +36,7 @@ scrabble-score |  chaining higher-order functions, HashMap (optional)
 pangram | filter, ascii (optional)
 nucleotide-count |  filter, entry api, mutablity, match
 word-count |  hashmap, str vs string, chars, entry api
+atbash-cipher | str vs string, primitive types, iterators, chars, ascii
 etl |  btree
 acronym |  map, flat_map, filter, loops, Vec
 sieve |  vector, map, while let (optional)

data/tracks/scala/config.json

@@ -6,6 +6,7 @@
   "problems": [
     "hello-world",
     "bob",
+    "sum-of-multiples",
     "hamming",
     "word-count",
     "pangram",
@@ -85,6 +86,13 @@
 				"Pattern matching"
       ]
 		},
+    {
+      "slug": "sum-of-multiples",
+      "difficulty": 1,
+      "topics": [
+	"Filtering"
+      ]
+		},
     {
       "slug": "hamming",
       "difficulty": 2,

data/tracks/scala/exercises/sum-of-multiples/build.sbt

@@ -0,0 +1,3 @@
+scalaVersion := "2.11.8"
+
+libraryDependencies += "org.scalatest" % "scalatest_2.11" % "2.2.5" % "test"

data/tracks/scala/exercises/sum-of-multiples/example.scala

@@ -0,0 +1,10 @@
+object SumOfMultiples {
+  def sumOfMultiples(factors: List[Int], limit: Int): Int = {
+    def isDivisibleBy(x: Int)(y: Int): Boolean = x % y == 0
+    def isMultiple(x: Int): Boolean = factors exists isDivisibleBy(x)
+
+    val multiples = (1 until limit) filter isMultiple
+    multiples sum
+  }
+}
+