trackler 1.0.1.0 → 1.0.1.1

data/tracks/elixir/exercises/clock/clock_test.exs

@@ -0,0 +1,281 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("clock.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure exclude: :pending, trace: true
+
+defmodule ClockTest do
+  use ExUnit.Case
+
+  #@tag :pending
+  test "to_string" do
+    try do
+      to_string(%Clock{})
+    rescue
+      Protocol.UndefinedError ->
+        refute(true, """
+          Can't convert Clock to string.
+          Hint: implement the String.Chars protocol for Clock.
+          http://elixir-lang.org/getting-started/protocols.html
+          http://elixir-lang.org/docs/stable/elixir/String.Chars.html
+          """)
+    end
+  end
+
+  describe "create" do
+    @tag :pending
+    test "on the hour" do
+      assert Clock.new(8, 0) |> to_string == "08:00"
+    end
+
+    @tag :pending
+    test "past the hour" do
+      assert Clock.new(11, 9) |> to_string == "11:09"
+    end
+
+    @tag :pending
+    test "midnight is zero hours" do
+      assert Clock.new(24, 0) |> to_string == "00:00"
+    end
+
+    @tag :pending
+    test "hour rolls over" do
+      assert Clock.new(25, 0) |> to_string == "01:00"
+    end
+
+    @tag :pending
+    test "hour rolls over continuously" do
+      assert Clock.new(100, 0) |> to_string == "04:00"
+    end
+
+    @tag :pending
+    test "sixty minutes is next hour" do
+      assert Clock.new(1, 60) |> to_string == "02:00"
+    end
+
+    @tag :pending
+    test "minutes roll over" do
+      assert Clock.new(0, 160) |> to_string == "02:40"
+    end
+
+    @tag :pending
+    test "minutes roll over continuously" do
+      assert Clock.new(0, 1723) |> to_string == "04:43"
+    end
+
+    @tag :pending
+    test "hour and minutes roll over" do
+      assert Clock.new(25, 160) |> to_string == "03:40"
+    end
+
+    @tag :pending
+    test "hour and minutes roll over continuously" do
+      assert Clock.new(201, 3001) |> to_string == "11:01"
+    end
+
+    @tag :pending
+    test "hour and minutes roll over to exactly midnight" do
+      assert Clock.new(72, 8640) |> to_string == "00:00"
+    end
+
+    @tag :pending
+    test "negative hour" do
+      assert Clock.new(-1, 15) |> to_string == "23:15"
+    end
+
+    @tag :pending
+    test "negative hour rolls over" do
+      assert Clock.new(-25, 0) |> to_string == "23:00"
+    end
+
+    @tag :pending
+    test "negative hour rolls over continuously" do
+      assert Clock.new(-91, 0) |> to_string == "05:00"
+    end
+
+    @tag :pending
+    test "negative minutes" do
+      assert Clock.new(1, -40) |> to_string == "00:20"
+    end
+
+    @tag :pending
+    test "negative minutes roll over" do
+      assert Clock.new(1, -160) |> to_string == "22:20"
+    end
+
+    @tag :pending
+    test "negative minutes roll over continuously" do
+      assert Clock.new(1, -4820) |> to_string == "16:40"
+    end
+
+    @tag :pending
+    test "negative hour and minutes roll over" do
+      assert Clock.new(-25, -160) |> to_string == "20:20"
+    end
+
+    @tag :pending
+    test "negative hour and minutes roll over continuously" do
+      assert Clock.new(-121, -5810) |> to_string == "22:10"
+    end
+  end
+
+  describe "add" do
+    @tag :pending
+    test "add minutes" do
+      assert Clock.new(10, 0) |> Clock.add(3) |> to_string == "10:03"
+    end
+
+    @tag :pending
+    test "add no minutes" do
+      assert Clock.new(6, 41) |> Clock.add(0) |> to_string == "06:41"
+    end
+
+    @tag :pending
+    test "add to next hour" do
+      assert Clock.new(0, 45) |> Clock.add(40) |> to_string == "01:25"
+    end
+
+    @tag :pending
+    test "add more than one hour" do
+      assert Clock.new(10, 0) |> Clock.add(61) |> to_string == "11:01"
+    end
+
+    @tag :pending
+    test "add more than two hours with carry" do
+      assert Clock.new(0, 45) |> Clock.add(160) |> to_string == "03:25"
+    end
+
+    @tag :pending
+    test "add across midnight" do
+      assert Clock.new(23, 59) |> Clock.add(2) |> to_string == "00:01"
+    end
+
+    @tag :pending
+    test "add more than one day (1500 min = 25 hrs)" do
+      assert Clock.new(5, 32) |> Clock.add(1500) |> to_string == "06:32"
+    end
+
+    @tag :pending
+    test "add more than two days" do
+      assert Clock.new(1, 1) |> Clock.add(3500) |> to_string == "11:21"
+    end
+
+    @tag :pending
+    test "subtract minutes" do
+      assert Clock.new(10, 3) |> Clock.add(-3) |> to_string == "10:00"
+    end
+
+    @tag :pending
+    test "subtract to previous hour" do
+      assert Clock.new(10, 3) |> Clock.add(-30) |> to_string == "09:33"
+    end
+
+    @tag :pending
+    test "subtract more than an hour" do
+      assert Clock.new(10, 3) |> Clock.add(-70) |> to_string == "08:53"
+    end
+
+    @tag :pending
+    test "subtract across midnight" do
+      assert Clock.new(0, 3) |> Clock.add(-4) |> to_string == "23:59"
+    end
+
+    @tag :pending
+    test "subtract more than two hours" do
+      assert Clock.new(0, 0) |> Clock.add(-160) |> to_string == "21:20"
+    end
+
+    @tag :pending
+    test "subtract more than two hours with borrow" do
+      assert Clock.new(6, 15) |> Clock.add(-160) |> to_string == "03:35"
+    end
+
+    @tag :pending
+    test "subtract more than one day (1500 min = 25 hrs)" do
+      assert Clock.new(5, 32) |> Clock.add(-1500) |> to_string == "04:32"
+    end
+
+    @tag :pending
+    test "subtract more than two days" do
+      assert Clock.new(2, 20) |> Clock.add(-3000) |> to_string == "00:20"
+    end
+  end
+
+  describe "==" do
+    @tag :pending
+    test "clocks with same time" do
+      assert Clock.new(15, 37) == Clock.new(15, 37)
+    end
+
+    @tag :pending
+    test "clocks a minute apart" do
+      refute Clock.new(15, 36) == Clock.new(15, 37)
+    end
+
+    @tag :pending
+    test "clocks an hour apart" do
+      refute Clock.new(14, 37) == Clock.new(15, 37)
+    end
+
+    @tag :pending
+    test "clocks with hour overflow" do
+      assert Clock.new(10, 37) == Clock.new(34, 37)
+    end
+
+    @tag :pending
+    test "clocks with hour overflow by several days" do
+      assert Clock.new(3, 11) == Clock.new(99, 11)
+    end
+
+    @tag :pending
+    test "clocks with negative hour" do
+      assert Clock.new(22, 40) == Clock.new(-2, 40)
+    end
+
+    @tag :pending
+    test "clocks with negative hour that wraps" do
+      assert Clock.new(17, 3) == Clock.new(-31, 3)
+    end
+
+    @tag :pending
+    test "clocks with negative hour that wraps multiple times" do
+      assert Clock.new(13, 49) == Clock.new(-83, 49)
+    end
+
+    @tag :pending
+    test "clocks with minute overflow" do
+      assert Clock.new(0, 1) == Clock.new(0, 1441)
+    end
+
+    @tag :pending
+    test "clocks with minute overflow by several days" do
+      assert Clock.new(2, 2) == Clock.new(2, 4322)
+    end
+
+    @tag :pending
+    test "clocks with negative minute" do
+      assert Clock.new(2, 40) == Clock.new(3, -20)
+    end
+
+    @tag :pending
+    test "clocks with negative minute that wraps" do
+      assert Clock.new(4, 10) == Clock.new(5, -1490)
+    end
+
+    @tag :pending
+    test "clocks with negative minute that wraps multiple times" do
+      assert Clock.new(6, 15) == Clock.new(6, -4305)
+    end
+
+    @tag :pending
+    test "clocks with negative hours and minutes" do
+      assert Clock.new(7, 32) == Clock.new(-12, -268)
+    end
+
+    @tag :pending
+    test "clocks with negative hours and minutes that wrap" do
+      assert Clock.new(18, 7) == Clock.new(-54, -11513)
+    end
+  end
+end

data/tracks/elixir/exercises/clock/example.exs

@@ -0,0 +1,55 @@
+defmodule Clock do
+  defstruct hour: 0, minute: 0
+  @type t :: %Clock{hour: integer, minute: integer}
+  @type t(hour, minute) :: %Clock{hour: hour, minute: minute}
+
+  @doc """
+  Returns a string representation of a clock:
+
+      iex> Clock.new(8, 9) |> to_string
+      "08:09"
+  """
+  @spec new(integer, integer) :: Clock.t
+  def new(hour, minute) do
+    rollover(%Clock{hour: hour, minute: minute})
+  end
+
+  @doc """
+  Adds two clock times:
+
+      iex> Clock.new(10, 0) |> Clock.add(3) |> to_string
+      "10:03"
+  """
+  @spec add(Clock.t, integer) :: Clock.t
+  def add(%Clock{hour: hour, minute: minute}, add_minute) do
+    new(hour, minute + add_minute)
+  end
+
+  defp rollover(%Clock{hour: hour, minute: minute}) do
+    {carry_hour, minute} = roll_minute(minute)
+    %Clock{hour: roll_hour(hour + carry_hour), minute: minute}
+  end
+
+  defp roll_hour(hour) when hour < 0 and rem(hour, 24) == 0, do: 0
+  defp roll_hour(hour) when hour < 0, do: 24 + rem(hour, 24)
+  defp roll_hour(hour) when hour >= 24, do: rem(hour, 24)
+  defp roll_hour(hour), do: hour
+
+  defp roll_minute(minute) when minute < 0 do
+    {div(minute, 60) - 1, 60 + rem(minute, 60)}
+  end
+  defp roll_minute(minute) when minute >= 60 do
+    {div(minute, 60), rem(minute, 60)}
+  end
+  defp roll_minute(minute), do: {0, minute}
+
+  defimpl String.Chars, for: Clock do
+    def to_string(%Clock{hour: hour, minute: minute}) do
+      "#{format(hour)}:#{format(minute)}"
+    end
+
+    defp format(number) do
+      number |> Integer.to_string |> String.pad_leading(2, "0")
+    end
+  end
+end

data/tracks/elixir/exercises/prime-factors/example.exs

@@ -1,10 +1,9 @@
 defmodule PrimeFactors do
   @spec factors_for(pos_integer) :: [pos_integer]
   def factors_for(number) do
-    do_factors(number)
+    do_factors(number, 2, [])
   end
 
-  defp do_factors(_, i \\ 2, acc \\ [])
   defp do_factors(1, _, acc),
     do: Enum.reverse(acc)
   defp do_factors(n, i, acc) when n < i * i,

data/tracks/elixir/exercises/robot-simulator/example.exs

@@ -27,15 +27,14 @@ defmodule RobotSimulator do
   def direction(%RobotSimulator{direction: dir}), do: dir
 
   defp orient(%RobotSimulator{} = robot, direction) when direction in @valid_directions do
-    %RobotSimulator{ robot | direction: direction }
+    %{ robot | direction: direction }
   end
   defp orient({ :error, _ } = error, _), do: error
   defp orient(_, _), do: { :error, "invalid direction" }
 
   defp place(%RobotSimulator{} = robot, { x, y } = position) when is_integer(x) and is_integer(y) do
-    %RobotSimulator{ robot | position: position }
+    %{ robot | position: position }
   end
-  defp place({ :error, _ } = error, _), do: error
   defp place(_, _), do: { :error, "invalid position" }
 
   defp move("R", %RobotSimulator{ direction: direction } = robot), do: robot |> orient(direction |> rotate_right)

data/tracks/elixir/mix.exs

@@ -6,7 +6,8 @@ defmodule ExercismTestRunner.Mixfile do
      version: "0.0.1",
      elixir: "~> 1.3",
      deps: deps,
-     test_paths: ["exercises"]]
+     test_paths: ["exercises"],
+     consolidate_protocols: false]
   end
 
   def application do

data/tracks/go/docs/TESTS.md

@@ -38,7 +38,7 @@ Your first goal it to get something to compile, even though it fails tests.  For
 
 ### Fixing
 
-Tests will often stop at the first error.  Fix that one, repeat until no errors.  `go test` has useful options.  `go test -v` will give more verbose output. `go test -run <regexp>` will run just tests with names that match <regexp>.
+Tests will often stop at the first error.  Fix that one, repeat until no errors.  `go test` has useful options.  `go test -v` will give more verbose output. `go test -run <regexp>` will run just tests with names that match `<regexp>`.
 
 Panics produce lots of output.  It might seem scary at first, but be brave.  Look at the very top of the panic output for the panic message.  That should give a general description of the problem.  Then read through the rest of it looking for the first reference to your code.  That will often point right to the problem.
 

data/tracks/go/exercises/gigasecond/gigasecond_test.go

@@ -1,8 +1,6 @@
 package gigasecond
 
 // Write a function AddGigasecond that works with time.Time.
-// Also define a variable Birthday set to your (or someone else's) birthday.
-// Run go test -v to see your gigasecond anniversary.
 
 import (
 	"os"

data/tracks/go/exercises/palindrome-products/palindrome_products_test.go

@@ -9,20 +9,15 @@ import (
 
 const targetTestVersion = 1
 
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
-	}
-}
+/* API to implement:
+
+type Product struct {
+	Product int // palindromic, of course
+	Factorizations [][2]int //list of all possible two-factor factorizations of Product, within given limits, in order
+ }
 
-// API to impliment:
-// type Product struct {
-// 	Product int // palindromic, of course
-// 	// list of all possible two-factor factorizations of Product, within
-// 	// given limits, in order
-// 	Factorizations [][2]int
-// }
-// func Products(fmin, fmax int) (pmin, pmax Product, error)
+ func Products(fmin, fmax int) (pmin, pmax Product, error)
+*/
 
 var testData = []struct {
 	// input to Products(): range limits for factors of the palindrome
@@ -45,29 +40,44 @@ var testData = []struct {
 		""},
 	{4, 10, Product{}, Product{}, "No palindromes"},
 	{10, 4, Product{}, Product{}, "fmin > fmax"},
-	/* bonus curiosities.  (can a negative number be a palindrome?
-	// most say no
-	{-99, -10, Product{}, Product{}, "Negative limits"},
-	// but you can still get non-negative products from negative factors.
+}
+
+// Bonus curiosities. Can a negative number be a palindrome? Most say no.
+var bonusData = []struct {
+	fmin, fmax int
+	pmin, pmax Product
+	errPrefix  string
+}{
+	// The following two test cases have the same input, but different expectations. Uncomment just one or the other.
+
+	/* Here you can test that you can reach the limit of the largest palindrome made of two 2-digit numbers.
+	{-99, -10, Product{}, Product{}, "Negative limits"}, */
+
+	// You can still get non-negative products from negative factors.
 	{-99, -10,
 		Product{121, [][2]int{{-11, -11}}},
 		Product{9009, [][2]int{{-99, -91}}},
 		""},
+
+	// The following two test cases have the same input, but different expectations. Uncomment just one or the other.
+
+	/*In case you reverse the *digits* you could have the following cases:
+	- the zero has to be considered
 	{-2, 2,
 		Product{0, [][2]int{{-2, 0}, {-1, 0}, {0, 0}, {0, 1}, {0, 2}}},
 		Product{4, [][2]int{{-2, -2}, {2, 2}}},
-		""},
-	// or you could reverse the *digits*, keeping the minus sign in place.
+		""}, */
+
+	// - you can keep the minus sign in place
 	{-2, 2,
 		Product{-4, [][2]int{{-2, 2}}},
 		Product{4, [][2]int{{-2, -2}, {2, 2}}},
 		""},
-	{
-	{0, (^uint(0))>>1, Product{}, Product{}, "This one's gonna overflow"},
-	*/
 }
 
 func TestPalindromeProducts(t *testing.T) {
+	// Uncomment the following line to add the bonus test to the default tests
+	// testData = append(testData, bonusData...)
 	for _, test := range testData {
 		// common preamble for test failures
 		ret := fmt.Sprintf("Products(%d, %d) returned",
@@ -99,6 +109,12 @@ func TestPalindromeProducts(t *testing.T) {
 	}
 }
 
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}
+
 func BenchmarkPalindromeProducts(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		for _, test := range testData {

data/tracks/haskell/.travis.yml

@@ -42,6 +42,13 @@ script:
         SET_RESOLVER="--resolver ${RESOLVER}"
     fi
 
+    test_exercise () {
+        stack test ${SET_RESOLVER} `# Select the correct resolver. `\
+                   --install-ghc   `# Download GHC if not in cache.`\
+                   --no-terminal   `# Terminal detection is broken.`\
+                   --pedantic      `# Enable -Wall and -Werror.    `
+    }
+
     for exercise in ${TRAVIS_BUILD_DIR}/exercises/* ; do
         pushd ${exercise}
 
@@ -50,13 +57,25 @@ script:
         mkdir -p "${HOME}/.foldercache/${exercise}/.stack-work"
         ln -f -s "${HOME}/.foldercache/${exercise}/.stack-work"
 
-        # Here we prepare the exercise to be tested by Stack.
-        MODULE=`sed -n 's/ *module \+\([a-zA-Z0-9]\+\).*/\1/p' src/Example.hs`
-        mv src/Example.hs "src/${MODULE}.hs"
+        if [ -f src/Example.hs ]; then
+            # Here we prepare the exercise to be tested by Stack.
+            MODULE=`sed -n 's/ *module \+\([a-zA-Z0-9]\+\).*/\1/p' src/Example.hs`
+            mv src/Example.hs "src/${MODULE}.hs"
+
+            test_exercise
+        elif ! stat -t examples/*/ > /dev/null 2>&1; then
+            echo "No examples for ${exercise}!"
+            exit 1
+        else
+            for example in examples/*/ ; do
+                echo "testing ${example}"
+                rm -f src/*.hs
+                mv ${example}/*.hs src
+                mv ${example}/package.yaml .
+
+                test_exercise
+            done
+        fi
 
-        stack test ${SET_RESOLVER} `# Select the correct resolver. `\
-                   --install-ghc   `# Download GHC if not in cache.`\
-                   --no-terminal   `# Terminal detection is broken.`\
-                   --pedantic      `# Enable -Wall and -Werror.    `
         popd
     done

data/tracks/haskell/config.json

@@ -3,75 +3,6 @@
   "language": "Haskell",
   "repository": "https://github.com/exercism/xhaskell",
   "active": true,
-  "problems": [
-    "leap",
-    "accumulate",
-    "sublist",
-    "grains",
-    "bob",
-    "sum-of-multiples",
-    "strain",
-    "hamming",
-    "rna-transcription",
-    "space-age",
-    "anagram",
-    "phone-number",
-    "nucleotide-count",
-    "grade-school",
-    "simple-linked-list",
-    "list-ops",
-    "word-count",
-    "etl",
-    "robot-name",
-    "meetup",
-    "beer-song",
-    "triangle",
-    "scrabble-score",
-    "roman-numerals",
-    "prime-factors",
-    "raindrops",
-    "allergies",
-    "atbash-cipher",
-    "all-your-base",
-    "bank-account",
-    "crypto-square",
-    "kindergarten-garden",
-    "robot-simulator",
-    "queen-attack",
-    "binary-search-tree",
-    "difference-of-squares",
-    "largest-series-product",
-    "luhn",
-    "clock",
-    "matrix",
-    "house",
-    "minesweeper",
-    "ocr-numbers",
-    "wordy",
-    "food-chain",
-    "linked-list",
-    "custom-set",
-    "nth-prime",
-    "palindrome-products",
-    "pascals-triangle",
-    "pig-latin",
-    "pythagorean-triplet",
-    "saddle-points",
-    "say",
-    "secret-handshake",
-    "series",
-    "sieve",
-    "simple-cipher",
-    "change",
-    "connect",
-    "parallel-letter-frequency",
-    "sgf-parsing",
-    "go-counting",
-    "zipper",
-    "forth",
-    "lens-person",
-    "pov"
-  ],
   "exercises": [
     {
       "slug": "leap",

data/tracks/haskell/exercises/anagram/examples/list-string/Anagram.hs

@@ -0,0 +1,10 @@
+module Anagram (anagramsFor) where
+import Data.List (sort)
+import Data.Char (toLower)
+
+anagramsFor :: String -> [String] -> [String]
+anagramsFor word = filter (isAnagram . normalize)
+  where
+    normalize xs = let nxs = map toLower xs in (nxs, sort nxs)
+    (nw, sw) = normalize word
+    isAnagram (w, s) = nw /= w && sw == s

data/tracks/haskell/exercises/anagram/examples/list-string/package.yaml

@@ -0,0 +1,17 @@
+name: anagram
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Anagram
+  source-dirs: src
+  dependencies:
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - anagram
+      - hspec

data/tracks/haskell/exercises/anagram/examples/set-text/package.yaml

@@ -0,0 +1,20 @@
+name: anagram
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Anagram
+  source-dirs: src
+  dependencies:
+    - containers
+    - multiset
+    - text
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - anagram
+      - hspec

data/tracks/haskell/exercises/anagram/package.yaml

@@ -9,9 +9,6 @@ library:
   dependencies:
   # - foo       # List here the packages you
   # - bar       # want to use in your solution.
-    - containers
-    - multiset
-    - text
 
 tests:
   test: