trackler 2.0.8.7 → 2.0.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 24f1a3e4a5a11da7a5de103a0fb55263037dba6c
-  data.tar.gz: 046a666971406ee116df5a9830b13332a2fbc175
+  metadata.gz: e62546727fedd95973681d450fffd9b90c5c3ede
+  data.tar.gz: fd0387e4ccf20d919d388471d2f4c26b83f04129
 SHA512:
-  metadata.gz: 7cff9d347f2f4ad9973fd4584c05ed5cf4e48b922521b09026bf248f94f721ceed614a8a728d6c0887e52eaec5db6dea5d3a04b2fdb7f03cd6ef65816cdeb464
-  data.tar.gz: 06896ee26a2bc013de9fa5720348313949c69a0f7ab5140a8f6c13fe00d0aa704d79e3d31a66e2a34c83be49e122f118292144a6acfd9de8bc262d57f57aad0f
+  metadata.gz: 2429ecbe7c6f1b7b0b9e389ee3ae0e5171057abb43f425fb20d1fb66b5077a9177f2b58d0fd1cbfc0f0d29e2026f511753e59b03b23f734cfaaa598ea92a6cdf
+  data.tar.gz: 7969ad1d115aa1d2a0dd93292009745b7d94b4f5d68e2d349123b6d8abff9743794e6003a4a2823e94e6e8d1d07577d6d668c605c33a78125b60b36438879e41

data/common/CONTRIBUTING.md

@@ -290,10 +290,10 @@ here.
 ## Porting an Exercise to Another Language Track
 
 To get a list of all the exercises that can be ported to a track,
-go to the url `http://exercism.io/languages/:track_id/contribute`.
+go to the url `http://exercism.io/languages/:track_id/todo`.
 
 For example here is the list of exercises that have not yet been implemented
-for the Ruby track: http://exercism.io/languages/ruby/contribute
+for the Ruby track: http://exercism.io/languages/ruby/todo
 
 Each unimplemented exercise links to existing implementations of the exercise in
 other language tracks, so that people can use those example solutions and test

data/common/exercises/diamond/canonical-data.json

@@ -0,0 +1,125 @@
+{
+    "exercise": "diamond",
+    "version": "1.0.0",
+    "comments": [
+        " The tests contained within this canonical data file are suitable   ",
+        " for value-based testing, in which each test case checks that the   ",
+        " value returned by the function under test is in every way          ",
+        " identical to a given expected value.                               ",
+        "                                                                    ",
+        " This exercise is also amenable to property-based testing, in which ",
+        " each test case verifies that the value returned by the function    ",
+        " under test exhibits a specific desired property.                   ",
+        "                                                                    ",
+        " Several tracks (notably, C# and Go) forgo the value-based tests    ",
+        " below in favor of property-based tests. If you are feeling         ",
+        " adventurous and would like to use this exercise to introduce the   ",
+        " concept of property-based testing to participants in your track,   ",
+        " please ignore the value-based tests below and instead reference    ",
+        " the test suites in the aforementioned tracks.                      "
+    ],
+    "cases": [
+        {
+            "description": "Degenerate case with a single 'A' row",
+            "property": "rows",
+            "input": "A",
+            "expected": [
+                "A"
+            ]
+        },
+        {
+            "description": "Degenerate case with no row containing 3 distinct groups of spaces",
+            "property": "rows",
+            "input": "B",
+            "expected": [
+                " A ",
+                "B B",
+                " A "
+            ]
+        },
+        {
+            "description": "Smallest non-degenerate case with odd diamond side length",
+            "property": "rows",
+            "input": "C",
+            "expected": [
+                "  A  ",
+                " B B ",
+                "C   C",
+                " B B ",
+                "  A  "
+            ]
+        },
+        {
+            "description": "Smallest non-degenerate case with even diamond side length",
+            "property": "rows",
+            "input": "D",
+            "expected": [
+                "   A   ",
+                "  B B  ",
+                " C   C ",
+                "D     D",
+                " C   C ",
+                "  B B  ",
+                "   A   "
+            ]
+        },
+        {
+            "description": "Largest possible diamond",
+            "property": "rows",
+            "input": "Z",
+            "expected": [
+                "                         A                         ",
+                "                        B B                        ",
+                "                       C   C                       ",
+                "                      D     D                      ",
+                "                     E       E                     ",
+                "                    F         F                    ",
+                "                   G           G                   ",
+                "                  H             H                  ",
+                "                 I               I                 ",
+                "                J                 J                ",
+                "               K                   K               ",
+                "              L                     L              ",
+                "             M                       M             ",
+                "            N                         N            ",
+                "           O                           O           ",
+                "          P                             P          ",
+                "         Q                               Q         ",
+                "        R                                 R        ",
+                "       S                                   S       ",
+                "      T                                     T      ",
+                "     U                                       U     ",
+                "    V                                         V    ",
+                "   W                                           W   ",
+                "  X                                             X  ",
+                " Y                                               Y ",
+                "Z                                                 Z",
+                " Y                                               Y ",
+                "  X                                             X  ",
+                "   W                                           W   ",
+                "    V                                         V    ",
+                "     U                                       U     ",
+                "      T                                     T      ",
+                "       S                                   S       ",
+                "        R                                 R        ",
+                "         Q                               Q         ",
+                "          P                             P          ",
+                "           O                           O           ",
+                "            N                         N            ",
+                "             M                       M             ",
+                "              L                     L              ",
+                "               K                   K               ",
+                "                J                 J                ",
+                "                 I               I                 ",
+                "                  H             H                  ",
+                "                   G           G                   ",
+                "                    F         F                    ",
+                "                     E       E                     ",
+                "                      D     D                      ",
+                "                       C   C                       ",
+                "                        B B                        ",
+                "                         A                         "
+            ]
+        }
+    ]
+}

data/common/exercises/difference-of-squares/metadata.yml

@@ -1,4 +1,4 @@
 ---
-blurb: "Find the difference between the sum of the squares and the square of the sum of the first N natural numbers."
+blurb: "Find the difference between the square of the sum and the sum of the squares of the first N natural numbers."
 source: "Problem 6 at Project Euler"
 source_url: "http://projecteuler.net/problem=6"

data/common/exercises/hello-world/description.md

@@ -4,7 +4,7 @@ or environment.
 
 The objectives are simple:
 
-- Write a function that says "Hello, World!".
+- Write a function that returns the string "Hello, World!".
 - Run the test suite and make sure that it succeeds.
 - Submit your solution and check it at the website.
 

data/common/exercises/perfect-numbers/canonical-data.json

@@ -0,0 +1,108 @@
+{
+    "exercise": "perfect-numbers",
+    "version": "1.0.0",
+    "cases": [
+        {
+            "description": "Perfect numbers",
+            "cases": [
+                {
+                    "description": "Smallest perfect number is classified correctly",
+                    "property": "classify",
+                    "input": 6,
+                    "expected": "perfect"
+                },
+                {
+                    "description": "Medium perfect number is classified correctly",
+                    "property": "classify",
+                    "input": 28,
+                    "expected": "perfect"
+                },
+                {
+                    "description": "Large perfect number is classified correctly",
+                    "property": "classify",
+                    "input": 33550336,
+                    "expected": "perfect"
+                }
+            ]
+        },
+        {
+            "description": "Abundant numbers",
+            "cases": [
+                {
+                    "description": "Smallest abundant number is classified correctly",
+                    "property": "classify",
+                    "input": 12,
+                    "expected": "abundant"
+                },
+                {
+                    "description": "Medium abundant number is classified correctly",
+                    "property": "classify",
+                    "input": 30,
+                    "expected": "abundant"
+                },
+                {
+                    "description": "Large abundant number is classified correctly",
+                    "property": "classify",
+                    "input": 33550335,
+                    "expected": "abundant"
+                }
+            ]
+        },
+        {
+            "description": "Deficient numbers",
+            "cases": [
+                {
+                    "description": "Smallest prime deficient number is classified correctly",
+                    "property": "classify",
+                    "input": 2,
+                    "expected": "deficient"
+                },
+                {
+                    "description": "Smallest non-prime deficient number is classified correctly",
+                    "property": "classify",
+                    "input": 4,
+                    "expected": "deficient"
+                },
+                {
+                    "description": "Medium deficient number is classified correctly",
+                    "property": "classify",
+                    "input": 32,
+                    "expected": "deficient"
+                },
+                {
+                    "description": "Large deficient number is classified correctly",
+                    "property": "classify",
+                    "input": 33550337,
+                    "expected": "deficient"
+                },
+                {
+                    "description": "Edge case (no factors other than itself) is classified correctly",
+                    "property": "classify",
+                    "input": 1,
+                    "expected": "deficient"
+                }
+            ]
+        },
+        {
+            "description": "Invalid inputs",
+            "cases": [
+                {
+                    "description": "Non-negative integer is rejected (not a natural number)",
+                    "property": "classify",
+                    "input": 0,
+                    "expected": {
+                        "error": "Classification is only possible for natural numbers."
+                    }
+                },
+                {
+                    "description": "Negative integer is rejected (not a natural number)",
+                    "property": "classify",
+                    "input": -1,
+                    "expected": {
+                        "error": "Classification is only possible for natural numbers."
+                    }
+                }
+            ]
+        }
+    ]
+}

data/common/exercises/word-search/description.md

@@ -4,15 +4,15 @@ words in them.
 For example:
 
 ```
-gefblpepre
-cbmdcimguc
-oikoknrjsm
-pbwjrqrota
-rixilelhgs
-woncqlispc
-schemekmgr
-alxhprubyi
-javaocamlp
+jefblpepre
+camdcimgtc
+oivokprjsm
+pbwasqroua
+rixilelhrs
+wolcqlirpc
+screeaumgr
+alxhpburyi
+jalaycalmp
 clojurermt
 ```
 

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.7"
+  VERSION = "2.0.8.8"
 end

data/tracks/delphi/exercises/bob/uBobTests.pas

@@ -13,71 +13,71 @@ type
     procedure Stating_something;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Shouting;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Asking_a_question;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Asking_a_question_with_a_trailing_space;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Asking_a_numeric_question;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Talking_forcefully;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Using_acronyms_in_regular_search;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Forceful_questions;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Shouting_numbers;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Only_numbers;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Question_with_only_numbers;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Shouting_with_special_characters;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Shouting_with_no_exclamation_mark;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Statement_containing_question_mark;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Prattling_on;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Silence;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Prolonged_silence;
 
     [Test]
-    [Ignore]
+    [Ignore('Comment this line to run this test')]
     procedure Multiple_line_question;
   end;
 

data/tracks/elixir/config.json

@@ -140,6 +140,12 @@
       "topics": [
       ]
     },
+    {
+      "slug": "all-your-base",
+      "difficulty": 2,
+      "topics": [
+      ]
+    },
     {
       "slug": "hamming",
       "difficulty": 2,

data/tracks/elixir/exercises/all-your-base/all-your-base-test.exs

@@ -0,0 +1,115 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("example.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure exclude: :pending, trace: true
+
+defmodule AllYourBaseTest do
+  use ExUnit.Case
+
+  test "convert single bit one to decimal" do
+    assert AllYourBase.convert([1], 2, 10) == [1]
+  end
+
+  @tag :pending
+  test "convert binary to single decimal" do
+    assert AllYourBase.convert([1, 0, 1], 2, 10) == [5]
+  end
+
+  @tag :pending
+  test "convert single decimal to binary" do
+    assert AllYourBase.convert([5], 10, 2) == [1, 0, 1]
+  end
+
+  @tag :pending
+  test "convert binary to multiple decimal" do
+    assert AllYourBase.convert([1, 0, 1, 0, 1, 0], 2, 10) == [4, 2]
+  end
+
+  @tag :pending
+  test "convert decimal to binary" do
+    assert AllYourBase.convert([4, 2], 10, 2) == [1, 0, 1, 0, 1, 0]
+  end
+
+  @tag :pending
+  test "convert trinary to hexadecimal" do
+    assert AllYourBase.convert([1, 1, 2, 0], 3, 16) == [2, 10]
+  end
+
+  @tag :pending
+  test "convert hexadecimal to trinary" do
+    assert AllYourBase.convert([2, 10], 16, 3) == [1, 1, 2, 0]
+  end
+
+  @tag :pending
+  test "convert 15-bit integer" do
+    assert AllYourBase.convert([3, 46, 60], 97, 73) == [6, 10, 45]
+  end
+
+  @tag :pending
+  test "convert empty list" do
+    assert AllYourBase.convert([], 2, 10) == nil
+  end
+
+  @tag :pending
+  test "convert single zero" do
+    assert AllYourBase.convert([0], 10, 2) == [0]
+  end
+
+  @tag :pending
+  test "convert multiple zeros" do
+    assert AllYourBase.convert([0, 0, 0], 10, 2) == [0]
+  end
+
+  @tag :pending
+  test "convert leading zeros" do
+    assert AllYourBase.convert([0, 6, 0], 7, 10) == [4, 2]
+  end
+
+  @tag :pending
+  test "convert negative digit" do
+    assert AllYourBase.convert([1, -1, 1, 0, 1, 0], 2, 10) == nil
+  end
+
+  @tag :pending
+  test "convert invalid positive digit" do
+    assert AllYourBase.convert([1, 2, 1, 0, 1, 0], 2, 10) == nil
+  end
+
+  @tag :pending
+  test "convert first base is one" do
+    assert AllYourBase.convert([], 1, 10) == nil
+  end
+
+  @tag :pending
+  test "convert second base is one" do
+    assert AllYourBase.convert([1, 0, 1, 0, 1, 0], 2, 1) == nil
+  end
+
+  @tag :pending
+  test "convert first base is zero" do
+    assert AllYourBase.convert([], 0, 10) == nil
+  end
+
+  @tag :pending
+  test "convert second base is zero" do
+    assert AllYourBase.convert([7], 10, 0) == nil
+  end
+
+  @tag :pending
+  test "convert first base is negative" do
+    assert AllYourBase.convert([1], -2, 10) == nil
+  end
+
+  @tag :pending
+  test "convert second base is negative" do
+    assert AllYourBase.convert([1], 2, -7) == nil
+  end
+
+  @tag :pending
+  test "convert both bases are negative" do
+    assert AllYourBase.convert([1], -2, -7) == nil
+  end
+
+end