trackler 2.0.8.31 → 2.0.8.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec9e8cd131aab975f2949305731a5eceef951290
-  data.tar.gz: f2825b0807a002fb5f28b2f0a42dc4159ed59353
+  metadata.gz: cc6eaccb2054506665379c75e4e6eac1a1b18f8e
+  data.tar.gz: b4c0e4d2306d08b14bb309970c0ec5f608d520a5
 SHA512:
-  metadata.gz: b14e3d7c62d9f65bd83e693a9d866c473d386a1e06a118d54ea1a840eebeabe0c26c570046afcb91836c07fcd7dfecf7c63a247f6fa6f6b7e81d058d03c257e2
-  data.tar.gz: 572d3829ff054e6e3526f16b338c2fba8782fd73effcdcf302ccb5d0ceaed948162bd2699300fc740db5a2d5b5731fb8a6594285b2b461e8b3d90f999b63604f
+  metadata.gz: 23a92f21a2611df2a1228a1f3383253469cc8d612e815cf858acd562b2550920094372b03a828ce41ba902d7025bf777b240ef166c95a30e7bcafaae6d818c22
+  data.tar.gz: 2b5276e0fc50034f1ac28587454c3839f44e1ae54ee97c60fb38d9e281f0222ae073b779f3b6fc521a90e2c4a83e8b3086e6cd4ef8ef03d35909446d67da20ae

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.31"
+  VERSION = "2.0.8.32"
 end

data/tracks/c/.travis.yml

@@ -3,7 +3,7 @@ language: bash
 
 before_install:
 - sudo apt-get -qq update
-- sudo apt-get install -y indent
+- sudo apt-get install -y indent valgrind
 
 script:
 - bin/fetch-configlet

data/tracks/c/bin/run-tests

@@ -30,6 +30,7 @@ for D in exercises/*; do
           elif [ ${PIPESTATUS[0]} -ne 0 ]; then
             exit 1
           fi
+          valgrind --quiet --leak-check=full --error-exitcode=1 ./tests.out >> /dev/null;
           cd ${CURRENT_DIR};
         }
     fi

data/tracks/c/exercises/atbash-cipher/src/example.c

@@ -30,7 +30,7 @@ static char get_decoded_character(char character)
 
 char *atbash_encode(const char *input)
 {
-   char *output = malloc(strlen(input) + (strlen(input) / GROUP_SIZE));
+   char *output = malloc(strlen(input) + (strlen(input) / GROUP_SIZE) + 1);
    int group_count = 0;
 
    output[0] = '\0';

data/tracks/c/exercises/phone-number/src/example.c

@@ -17,25 +17,28 @@
 
 static void remove_leading_digit(char *phone_number)
 {
-   char *temp = calloc(VALID_NUMBER_LENGTH, sizeof(char));
-   strcpy(temp, &phone_number[1]);
-   strcpy(phone_number, temp);
-   free(temp);
+   for (size_t i = 0; phone_number[i]; ++i) {
+      phone_number[i] = phone_number[i + 1];
+   }
 }
 
 char *phone_number_clean(const char *input)
 {
-   char *output = calloc(VALID_NUMBER_LENGTH + 1, sizeof(char));
+   char *output = calloc(VALID_NUMBER_LENGTH + 2, sizeof(char));
 
+   size_t j = 0;
    for (size_t i = 0; i < strlen(input); i++) {
       if (isdigit(input[i])) {
-         strncat(output, &input[i], 1);
+         if (j > VALID_NUMBER_LENGTH) {
+            break;
+         }
+         output[j++] = input[i];
       }
    }
 
-   if ((strlen(output) > 11) || (strlen(output) < 10)) {
+   if (j > 11 || j < 10) {
       strcpy(output, INVALID_NUMBER_RESULT);
-   } else if (strlen(output) == 11) {
+   } else if (j == 11) {
       if (output[0] == '1') {
          remove_leading_digit(output);
       } else {
@@ -57,7 +60,7 @@ char *phone_number_get_area_code(const char *input)
 char *phone_number_format(const char *input)
 {
    char *cleaned_input = phone_number_clean(input);
-   char *output = calloc(FORMATTED_LENGTH, sizeof(char));
+   char *output = calloc(FORMATTED_LENGTH + 1, sizeof(char));
 
    sprintf(output, "(%.3s) %.3s-%.4s", cleaned_input,
            &cleaned_input[AREA_CODE_LENGTH], &cleaned_input[EXTENSION_OFFSET]);

data/tracks/c/exercises/rna-transcription/src/example.c

@@ -5,7 +5,7 @@
 char *to_rna(const char *dna)
 {
    size_t len = strlen(dna);
-   char *rna = malloc(sizeof(char) * len);
+   char *rna = calloc(sizeof(char), len + 1);
 
    for (size_t i = 0; i < len; i++) {
       switch (dna[i]) {

data/tracks/c/exercises/roman-numerals/src/example.c

@@ -28,7 +28,7 @@ const numeral_values_t numeral_values[] = {
 
 char *to_roman_numeral(unsigned int number)
 {
-   char *numerals = calloc(0, sizeof(char) * MAX_NUMERAL_LENGTH);
+   char *numerals = calloc(sizeof(char), MAX_NUMERAL_LENGTH);
 
    for (size_t i = 0; i < NUM_OF_ELEMENTS(numeral_values); i++) {
       while (number >= numeral_values[i].value) {

data/tracks/c/exercises/sieve/src/example.c

@@ -45,6 +45,7 @@ unsigned int sieve(const unsigned int limit, primesArray_t primes)
             primes[numberOfPrimes++] = i;
          }
       }
+      free(numberIsPrime);
    }
    return numberOfPrimes;
 }

data/tracks/cpp/README.md

@@ -1,7 +1,7 @@
-[![Travis Build Status](https://api.travis-ci.org/exercism/xcpp.png?branch=master)](https://travis-ci.org/exercism/xcpp)
-
 # xC++
 
+[![Travis Build Status](https://api.travis-ci.org/exercism/xcpp.svg?branch=master)](https://travis-ci.org/exercism/xcpp)
+
 Exercism Exercises in C++
 
 ## Contributing Guide

data/tracks/cpp/config.json

@@ -14,6 +14,13 @@
     "point-mutations"
   ],
   "exercises": [
+    {
+      "difficulty": 1,
+      "slug": "hello-world",
+      "topics": [
+        "strings"      
+      ]
+    },
     {
       "difficulty": 1,
       "slug": "bob",

data/tracks/cpp/exercises/hello-world/CMakeLists.txt

@@ -0,0 +1,59 @@
+# Get the exercise name from the current directory
+get_filename_component(exercise ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+
+# Basic CMake project
+cmake_minimum_required(VERSION 2.8.11)
+
+# Name the project after the exercise
+project(${exercise} CXX)
+
+# Locate Boost libraries: unit_test_framework, date_time and regex
+set(Boost_USE_STATIC_LIBS ON)
+set(Boost_USE_MULTITHREADED ON)
+set(Boost_USE_STATIC_RUNTIME OFF)
+find_package(Boost 1.55 REQUIRED COMPONENTS unit_test_framework date_time regex)
+
+# Enable C++11 features on gcc/clang
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(GNU|Clang)")
+    set(CMAKE_CXX_FLAGS "-std=c++11")
+endif()
+
+# Configure to run all the tests?
+if(${EXERCISM_RUN_ALL_TESTS})
+    add_definitions(-DEXERCISM_RUN_ALL_TESTS)
+endif()
+
+# Get a source filename from the exercise name by replacing -'s with _'s
+string(REPLACE "-" "_" file ${exercise})
+
+# Implementation could be only a header
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${file}.cpp)
+    set(exercise_cpp ${file}.cpp)
+else()
+    set(exercise_cpp "")
+endif()
+
+# Include a test helper header if it exists
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/require_equal_containers.h)
+    set(test_helper require_equal_containers.h)
+else()
+    set(test_helper "")
+endif()
+
+# Build executable from sources and headers
+add_executable(${exercise} ${file}_test.cpp ${test_helper} ${exercise_cpp} ${file}.h)
+
+# We need boost includes
+target_include_directories(${exercise} PRIVATE ${Boost_INCLUDE_DIRS})
+
+# We need boost libraries
+target_link_libraries(${exercise} ${Boost_LIBRARIES})
+
+# Tell MSVC not to warn us about unchecked iterators in debug builds
+if(${MSVC})
+    set_target_properties(${exercise} PROPERTIES
+        COMPILE_DEFINITIONS_DEBUG _SCL_SECURE_NO_WARNINGS)
+endif()
+
+# Run the tests on every build
+add_custom_command(TARGET ${exercise} POST_BUILD COMMAND ${exercise})

data/tracks/cpp/exercises/hello-world/example.cpp

@@ -0,0 +1,13 @@
+#include "hello_world.h"
+
+using namespace std;
+
+namespace hello_world
+{
+	
+string hello()
+{
+    return "Hello, World!";
+}
+
+}

data/tracks/cpp/exercises/hello-world/hello_world.h

@@ -0,0 +1,12 @@
+#if !defined(HELLO_WORLD_H)
+#define HELLO_WORLD_H
+
+#include <string>
+
+namespace hello_world {
+
+std::string hello();
+
+}
+
+#endif

data/tracks/cpp/exercises/hello-world/hello_world_test.cpp

@@ -0,0 +1,8 @@
+#include "hello_world.h"
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE(test_hello)
+{
+    BOOST_REQUIRE_EQUAL("Hello, World!", hello_world::hello());
+}

data/tracks/csharp/exercises/clock/ClockTest.cs

@@ -111,4 +111,11 @@ public void Overflown_clocks_with_same_time_are_equal()
         var clock2 = new Clock(38, 30);
         Assert.Equal(clock2, clock1);
     }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_wrap_around_more_than_one_day()
+    {
+        var clock = new Clock(10).Subtract(7224);
+        Assert.Equal("09:36", clock.ToString());
+    }
 }

data/tracks/csharp/exercises/luhn/LuhnTest.cs

@@ -2,15 +2,84 @@
 
 public class LuhnTest
 {
-    [Theory]
-    [InlineData("1", false)] // single digit strings can not be valid
-    [InlineData("0", false)] // a single zero is invalid
-    [InlineData("046 454 286", true)] // valid Canadian SIN
-    [InlineData("046 454 287", false)] // invalid Canadian SIN
-    [InlineData("8273 1232 7352 0569", false)] // invalid credit card
-    [InlineData("827a 1232 7352 0569", false)] // strings that contain non-digits are not valid
-    public void ValidateChecksum(string number, bool expected)
-    {
-        Assert.Equal(expected, Luhn.IsValid(number));
-    }
-}
+    [Fact]
+    public void Single_digit_strings_can_not_be_valid()
+    {
+        Assert.False(Luhn.IsValid("1"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void A_single_zero_is_invalid()
+    {
+        Assert.False(Luhn.IsValid("0"));
+    }
+
+
+    [Fact(Skip = "Remove to run test")]
+    public void A_simple_valid_SIN_that_remains_valid_if_reversed()
+    {
+        Assert.True(Luhn.IsValid("059"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void A_simple_valid_SIN_that_becomes_invalid_if_reversed()
+    {
+        Assert.True(Luhn.IsValid("59"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void A_valid_Canadian_SIN()
+    {
+        Assert.True(Luhn.IsValid("055 444 285"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Invalid_Canadian_SIN()
+    {
+        Assert.False(Luhn.IsValid("055 444 286"));
+    }
+
+
+    [Fact(Skip = "Remove to run test")]
+    public void Invalid_credit_card()
+    {
+        Assert.False(Luhn.IsValid("8273 1232 7352 0569"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Valid_strings_with_a_non_digit_included_become_invalid()
+    {
+        Assert.False(Luhn.IsValid("055a 444 285"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Valid_strings_with_punctuation_included_become_invalid()
+    {
+        Assert.False(Luhn.IsValid("055-444-285"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Valid_strings_with_symbols_included_become_invalid()
+    {
+        Assert.False(Luhn.IsValid("055£ 444$ 285"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Single_zero_with_space_is_invalid()
+    {
+        Assert.False(Luhn.IsValid(" 0"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void More_than_a_single_zero_is_valid()
+    {
+        Assert.True(Luhn.IsValid("0000 0"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Input_digit_9_is_correctly_converted_to_output_digit_9()
+    {
+        Assert.True(Luhn.IsValid("091"));
+    }
+
+}

data/tracks/csharp/generators/Exercises/LuhnExercise.cs

@@ -0,0 +1,9 @@
+namespace Generators.Exercises
+{
+    public class LuhnExercise : BooleanExercise
+    {
+        public LuhnExercise() : base("luhn")
+        {
+        }
+    }
+}

data/tracks/elixir/exercises/change/change.exs

@@ -2,21 +2,21 @@ defmodule Change do
   @doc """
     Determine the least number of coins to be given to the user such
     that the sum of the coins' value would equal the correct amount of change.
-    It returns :error if it is not possible to compute the right amount of coins.
-    Otherwise returns the tuple {:ok, map_of_coins}
+    It returns {:error, "cannot change"} if it is not possible to compute the
+    right amount of coins. Otherwise returns the tuple {:ok, list_of_coins}
 
     ## Examples
 
-      iex> Change.generate(3, [5, 10, 15])
-      :error
+      iex> Change.generate([5, 10, 15], 3)
+      {:error, "cannot change"}
 
-      iex> Change.generate(18, [1, 5, 10])
-      {:ok, %{1 => 3, 5 => 1, 10 => 1}}
+      iex> Change.generate([1, 5, 10], 18)
+      {:ok, [1, 1, 1, 5, 10]}
 
   """
 
-  @spec generate(integer, list) :: {:ok, map} | :error
-  def generate(amount, values) do
+  @spec generate(list, integer) :: {:ok, list} | {:error, String.t}
+  def generate(coins, target) do
 
   end
 end

data/tracks/elixir/exercises/change/change_test.exs

@@ -8,43 +8,70 @@ ExUnit.configure exclude: :pending, trace: true
 defmodule ChangeTest do
   use ExUnit.Case
 
-  test "returns :error on empty list" do
-    assert Change.generate(1, []) == :error
+  # @tag :pending
+  test "no coins make 0 change" do
+      coins = [1, 5, 10, 21, 25]
+      expected = []
+      assert Change.generate(coins, 0) == {:ok, expected}
   end
 
   @tag :pending
-  test "generates the correct change when only one coin type is needed" do
-    change = %{1 => 5, 10 => 0}
-    assert Change.generate(5, [1, 10]) == {:ok, change}
+  test "cannot find negative change values" do
+      coins = [1, 2, 5]
+      assert Change.generate(coins, -5) == {:error, "cannot change"}
   end
 
   @tag :pending
-  test "generates the correct change when multiple coin types are needed" do
-    change = %{1 => 3, 5 => 1, 10 => 1}
-    assert Change.generate(18, [1, 5, 10]) == {:ok, change}
+  test "error testing for change smaller than the smallest of coins" do
+      coins = [5, 10]
+      assert Change.generate(coins, 3) == {:error, "cannot change"}
   end
 
   @tag :pending
-  test "returns :error when it is not possible to generate change" do
-    assert Change.generate(3, [5, 10, 25]) == :error
+  test "single coin change" do
+      coins = [1, 5, 10, 25, 100]
+      expected = [25]
+      assert Change.generate(coins, 25) == {:ok, expected}
   end
 
   @tag :pending
-  test "generates change using only small coins when it is not possible to combine them with larger coins" do
-    change = %{3 => 34, 100 => 0}
-    assert Change.generate(102, [3, 100]) == {:ok, change}
+  test "multiple coin change" do
+      coins = [1, 5, 10, 25, 100]
+      expected = [5, 10]
+      assert Change.generate(coins, 15) == {:ok, expected}
+  end
+
+   @tag :pending
+   test "possible change without unit coins available" do
+      coins = [2, 5, 10, 20, 50]
+      expected = [2, 2, 2, 5, 10]
+      assert Change.generate(coins, 21) == {:ok, expected}
+   end
+
+  @tag :pending
+  test "change with Lilliputian Coins" do
+      coins = [1, 4, 15, 20, 50]
+      expected = [4, 4, 15]
+      assert Change.generate(coins, 23) == {:ok, expected}
+  end
+
+  @tag :pending
+  test "change with Lower Elbonia Coins" do
+      coins = [1, 5, 10, 21, 25]
+      expected = [21, 21, 21]
+      assert Change.generate(coins, 63) == {:ok, expected}
   end
 
   @tag :pending
-  test "generates the same change given any coin order" do
-    change = %{1 => 3, 5 => 1, 10 => 1}
-    assert Change.generate(18, [1, 5, 10]) == {:ok, change}
-    assert Change.generate(18, [10, 5, 1]) == {:ok, change}
+  test "large target values" do
+      coins = [1, 2, 5, 10, 20, 50, 100]
+      expected = [2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100]
+      assert Change.generate(coins, 999) == {:ok, expected}
   end
 
   @tag :pending
-  test "generates the correct change for large values with many coins" do
-    change = %{1 => 3, 5 => 1, 10 => 0, 25 => 1, 100 => 1}
-    assert Change.generate(133, [1, 5, 10, 25, 100]) == {:ok, change}
+  test "error if no combination can add up to target" do
+      coins = [5, 10]
+      assert Change.generate(coins, 94) == {:error, "cannot change"}
   end
 end

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

@@ -2,35 +2,38 @@ defmodule Change do
   @doc """
     Determine the least number of coins to be given to the user such
     that the sum of the coins' value would equal the correct amount of change.
-    It returns :error if it is not possible to compute the right amount of coins.
-    Otherwise returns the tuple {:ok, map_of_coins}
+    It returns {:error, "cannot change"} if it is not possible to compute the
+    right amount of coins. Otherwise returns the tuple {:ok, list_of_coins}
 
     ## Examples
 
-      iex> Change.generate(3, [5, 10, 15])
-      :error
+      iex> Change.generate([5, 10, 15], 3)
+      {:error, "cannot change"}
 
-      iex> Change.generate(18, [1, 5, 10])
-      {:ok, %{1 => 3, 5 => 1, 10 => 1}}
+      iex> Change.generate([1, 5, 10], 18)
+      {:ok, [1, 1, 1, 5, 10]}
 
   """
 
-  @spec generate(integer, list) :: {:ok, map} | :error
-  def generate(amount, values) do
-    values |> Enum.sort(&(&2 < &1)) |> generate(amount, %{})
+  @spec generate(list, integer) :: {:ok, list} | {:error, String.t}
+  def generate(coins, target) do
+    coins |> Enum.sort(&>/2) |> generate(target, [], {:error, "cannot change"})
   end
 
-  defp generate(_, 0, acc), do: {:ok, acc}
-  defp generate([], _, _), do: :error
-  defp generate(values = [h | t], amount, acc) do
-    if amount >= h && divisible?(amount - h, values) do
-      generate(values, amount - h, Map.update(acc, h, 1, &(&1 + 1)))
-    else
-      generate(t, amount, Map.put_new(acc, h, 0))
-    end
+  defp generate(_, _, current, {:ok, best}) when length(current) >= length(best) do
+    {:ok, best}
   end
-
-  defp divisible?(num, values) do
-    Enum.any?(values, &(rem(num, &1) == 0))
+  defp generate(_, 0, current, _) do
+    {:ok, current}
+  end
+  defp generate([], _, _, best) do
+    best
+  end
+  defp generate([coin | coins], target, current, best) when coin > target do
+    generate(coins, target, current, best)
+  end
+  defp generate([coin | coins], target, current, best) do
+    first_try = generate([coin | coins], target - coin, [coin | current], best)
+    generate(coins, target, current, first_try)
   end
 end

data/tracks/elixir/exercises/run-length-encoding/example.exs

@@ -2,15 +2,11 @@ defmodule RunLengthEncoder do
 
   @spec encode(String.t) :: String.t
   def encode(string) do
-    Regex.scan(~r/([a-zA-Z ])\1*/, string)
+    Regex.scan(~r/([a-zA-Z\s])\1*/, string)
     |> Enum.map_join(fn([run, c]) ->
-      if String.match?(run, ~r/\s+/) do
-        run
-      else
-        times = String.length(run)
-        number = if times == 1 do "" else times end
-          "#{number}#{c}"
-      end
+      times = String.length(run)
+      number = if times == 1 do "" else times end
+        "#{number}#{c}"
     end)
   end
 

data/tracks/elixir/exercises/run-length-encoding/rle_test.exs

@@ -13,10 +13,30 @@ defmodule RunLengthEncoderTest do
   end
 
   @tag :pending
-  test "encode single characters only" do
+  test "encode single characters only are encoded without count" do
     assert RunLengthEncoder.encode("XYZ") === "XYZ"
   end
 
+  @tag :pending
+  test "encode string with no single characters" do
+    assert RunLengthEncoder.encode("AABBBCCCC") == "2A3B4C"
+  end
+
+  @tag :pending
+  test "encode single characters mixed with repeated characters" do
+    assert RunLengthEncoder.encode("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB") === "12WB12W3B24WB"
+  end
+
+  @tag :pending
+  test "encode multiple whitespace mixed in string" do
+    assert RunLengthEncoder.encode("  hsqq qww  ") === "2 hs2q q2w2 "
+  end
+
+  @tag :pending
+  test "encode lowercase characters" do
+    assert RunLengthEncoder.encode("aabbbcccc") === "2a3b4c"
+  end
+
   @tag :pending
   test "decode empty string" do
     assert RunLengthEncoder.decode("") === ""
@@ -28,27 +48,27 @@ defmodule RunLengthEncoderTest do
   end
 
   @tag :pending
-  test "encode simple" do
-    assert RunLengthEncoder.encode("AABBBCCCC") == "2A3B4C"
+  test "decode string with no single characters" do
+    assert RunLengthEncoder.decode("2A3B4C") == "AABBBCCCC"
   end
 
   @tag :pending
-  test "decode simple" do
-    assert RunLengthEncoder.decode("2A3B4C") == "AABBBCCCC"
+  test "decode single characters with repeated characters" do
+    assert RunLengthEncoder.decode("12WB12W3B24WB") === "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
   end
 
   @tag :pending
-  test "encode with single values" do
-    assert RunLengthEncoder.encode("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB") === "12WB12W3B24WB"
+  test "decode multiple whitespace mixed in string" do
+    assert RunLengthEncoder.decode("2 hs2q q2w2 ") === "  hsqq qww  "
   end
 
   @tag :pending
-  test "decode with single values" do
-    assert RunLengthEncoder.decode("12WB12W3B24WB") === "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
+  test "decode lower case string" do
+    assert RunLengthEncoder.decode("2a3b4c") === "aabbbcccc"
   end
 
   @tag :pending
-  test "decode(encode(...)) combination" do
+  test "encode followed by decode gives original string" do
     original = "zzz ZZ  zZ"
     encoded = RunLengthEncoder.encode(original)
     assert RunLengthEncoder.decode(encoded) === original

data/tracks/groovy/config.json

@@ -20,27 +20,27 @@
       "topics": []
     },
     {
-      "difficulty": 1,
+      "difficulty": 2,
       "slug": "hamming",
       "topics": []
     },
     {
-      "difficulty": 1,
+      "difficulty": 4,
       "slug": "gigasecond",
       "topics": []
     },
     {
-      "difficulty": 1,
+      "difficulty": 3,
       "slug": "raindrops",
       "topics": []
     },
     {
-      "difficulty": 1,
+      "difficulty": 2,
       "slug": "rna-transcription",
       "topics": []
     },
     {
-      "difficulty": 1,
+      "difficulty": 2,
       "slug": "difference-of-squares",
       "topics": []
     },
@@ -50,32 +50,32 @@
       "topics": []
     },
     {
-      "difficulty": 1,
+      "difficulty": 4,
       "slug": "nth-prime",
       "topics": []
     },
     {
-      "difficulty": 1,
+      "difficulty": 3,
       "slug": "robot-name",
       "topics": []
     },
     {
-      "difficulty": 1,
+      "difficulty": 4,
       "slug": "roman-numerals",
       "topics": []
     },
     {
-      "difficulty": 1,
+      "difficulty": 2,
       "slug": "grains",
       "topics": []
     },
     {
-      "difficulty": 1,
+      "difficulty": 3,
       "slug": "word-count",
       "topics": []
     },
     {
-      "difficulty": 1,
+      "difficulty": 3,
       "slug": "phone-number",
       "topics": []
     }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.0.8.31
+  version: 2.0.8.32
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-25 00:00:00.000000000 Z
+date: 2017-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -1178,6 +1178,10 @@ files:
 - tracks/cpp/exercises/hamming/example.cpp
 - tracks/cpp/exercises/hamming/example.h
 - tracks/cpp/exercises/hamming/hamming_test.cpp
+- tracks/cpp/exercises/hello-world/CMakeLists.txt
+- tracks/cpp/exercises/hello-world/example.cpp
+- tracks/cpp/exercises/hello-world/hello_world.h
+- tracks/cpp/exercises/hello-world/hello_world_test.cpp
 - tracks/cpp/exercises/hexadecimal/CMakeLists.txt
 - tracks/cpp/exercises/hexadecimal/example.cpp
 - tracks/cpp/exercises/hexadecimal/example.h
@@ -1841,6 +1845,7 @@ files:
 - tracks/csharp/generators/Exercises/Exercise.cs
 - tracks/csharp/generators/Exercises/IsogramExercise.cs
 - tracks/csharp/generators/Exercises/LeapExercise.cs
+- tracks/csharp/generators/Exercises/LuhnExercise.cs
 - tracks/csharp/generators/Exercises/NthPrimeExercise.cs
 - tracks/csharp/generators/Exercises/PerfectNumbersExercise.cs
 - tracks/csharp/generators/Exercises/PigLatinExercise.cs