trackler 2.0.6.22 → 2.0.6.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c345469ef70e6d1cbdbb6629050afdbcba27689
-  data.tar.gz: 9ed54ec084197a08ff4bda1d1bdf6b4564870250
+  metadata.gz: 9cf87d7b9dd56a6a58b3c1d87d9a23ef21f730d8
+  data.tar.gz: eb35ab1854d690d7fc64b61977fe31f29d3735c5
 SHA512:
-  metadata.gz: b6bc4c64ea54985dac6440d9d36d65d8c33023ec2542412cb1a3fdd25ff3c83aa69d49bdc9ee15ec239ca08cd8efa6b7af9dd08270959c772744ee4cd0bba5d9
-  data.tar.gz: 2200f840688526466ff8de0f90e81638d9409f6c261a008fb1245da36d81f672b344bd117e76c94ee9e8ce8f09eed41ad5650926c73463899346c5035fc0134f
+  metadata.gz: fa2bf7b5e78b0ae76d088865728a0703ff112c64841abcc5eb621e9bfc76b367ff3c247d27788c990034c6e9af98a64d7cb2862c4c2a881189b41d909bb6c6b3
+  data.tar.gz: 967886a22857e8f2e2bebb00ffd20a2ed6102c649a66f9e555a76524dbaf63371fd83239697bee6866cc0fd69858bd7f66c644e5e006cb2d72a672df800685b7

data/common/exercises/book-store/canonical-data.json

@@ -1,106 +1,87 @@
 {
-   "book-store": {
-      "description": [
-                       "Calculate lowest price for shopping basket only ",
-                       "containing books from a single series.  There is no ",
-                       "discount advantage for having more than one copy of ",
-                       "any single book in a grouping."
-                     ],
-      "cases": [
+  "book-store": {
+    "description": [
+      "Calculate lowest price for a shopping basket containing ",
+      "books only from a single series.  There is no ",
+      "discount advantage for having more than one copy of ",
+      "any single book in a grouping."
+    ],
+    "total": {
+       "description": "returns the total basket price after applying best discount",
+       "cases": [
          {
-            "description": "A basket containing only a single book.",
-            "basket": [1],
-            "targetgrouping": [[1]],
-            "expected": 8.0
+           "description": "Only a single book",
+           "basket": [1],
+           "targetgrouping": [[1]],
+           "expected": 8.00
          },
          {
-            "description":  "A basket containing only two of the same book.",
-            "basket": [2, 2],
-            "targetgrouping": [[2], [2]],
-            "expected": 16.0
+           "description": "Two of the same book",
+           "basket": [2,2],
+           "targetgrouping": [[2],[2]],
+           "expected": 16.00
          },
          {
-            "description": "No charge to carry around an empty basket.",
-            "basket": [],
-            "targetgrouping": [],
-            "expected": 0.0
+           "description": "Empty basket",
+           "basket": [],
+           "targetgrouping": [],
+           "expected": 0.00
          },
          {
-            "description": "A basket containing only two different books.",
-            "basket": [1, 2],
-            "targetgrouping": [[1, 2]],
-            "expected": 15.2
+           "description": "Two different books",
+           "basket": [1,2],
+           "targetgrouping": [[1,2]],
+           "expected": 15.20
          },
          {
-            "description": "A basket of three different books.",
-            "basket": [1, 2, 3],
-            "targetgrouping": [[1, 2, 3]],
-            "expected": 21.60
+           "description": "Three different books",
+           "basket": [1,2,3],
+           "targetgrouping": [[1,2,3]],
+           "expected": 21.60
          },
          {
-            "description": "A basket of four different books.",
-            "basket": [1, 2, 3, 4],
-            "targetgrouping": [[1, 2, 3, 4]],
-            "expected": 25.60
+           "description": "Four different books",
+           "basket": [1,2,3,4],
+           "targetgrouping": [[1,2,3,4]],
+           "expected": 25.60
          },
          {
-            "description": "A basket of five different books.",
-            "basket": [1, 2, 3, 4, 5],
-            "targetgrouping": [[1, 2, 3, 4, 5]],
-            "expected": 30.00
+           "description": "Five different books",
+           "basket": [1,2,3,4,5],
+           "targetgrouping": [[1,2,3,4,5]],
+           "expected": 30.00
          },
          {
-            "description": [
-                            "A basket containing eight books consisting of a ",
-                            "pair each of the first three books plus one copy ",
-                            "each of the last two books.  Please pay careful ",
-                            "attention to this particular target grouping, it ",
-                            "is not intuitive, but does grant the largest ",
-                            "discount."
-                           ],
-            "basket": [1, 1, 2, 2, 3, 3, 4, 5],
-            "targetgrouping": [[1, 2, 3, 4], [1, 2, 3, 5]],
-            "expected": 51.20
+           "description": "Two each of first 3 books and 1 copy each of rest",
+           "basket": [1,1,2,2,3,3,4,5],
+           "targetgrouping": [[1,2,3,4],[1,2,3,5]],
+           "expected": 51.20
          },
          {
-            "description": [
-                            "A basket containing nine books consisting of a ",
-                            "pair each of the first four books plus one of ",
-                            "the last book."
-                           ],
-            "basket": [1, 1, 2, 2, 3, 3, 4, 4, 5],
-            "targetgrouping": [[1, 2, 3, 4, 5], [1, 2, 3, 4]],
-            "expected": 55.60
+           "description": "Two each of first 4 books and 1 copy each of rest",
+           "basket": [1,1,2,2,3,3,4,4,5],
+           "targetgrouping": [[1,2,3,4,5],[1,2,3,4]],
+           "expected": 55.60
          },
          {
-            "description": [
-                            "A basket containing ten books consisting of two ",
-                            "copies of each book in the series."
-                           ],
-            "basket":  [1, 1, 2, 2, 3, 3, 4, 4, 5, 5],
-            "targetgrouping": [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
-            "expected": 60.00
+           "description": "Two copies of each book",
+           "basket": [1,1,2,2,3,3,4,4,5,5],
+           "targetgrouping": [[1,2,3,4,5],[1,2,3,4,5]],
+           "expected": 60.00
          },
          {
-            "description": [
-                            "A basket containing eleven books consisting ",
-                            "of three copies of the first book plus two each ",
-                            "of the remaining four books in the series."
-                           ],
-            "basket": [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1],
-            "targetgrouping": [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1]],
-            "expected": 68.00
+           "description": "Three copies of first book and 2 each of remaining",
+           "basket": [1,1,2,2,3,3,4,4,5,5,1],
+           "targetgrouping": [[1,2,3,4,5],[1,2,3,4,5],[1]],
+           "expected": 68.00
          },
          {
-            "description": [
-                            "A basket containing twelve books consisting of ",
-                            "three copies of the first two books, plus two ",
-                            "each of the remaining three books in the series."
-                           ],
-            "basket": [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2],
-            "targetgrouping": [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2]],
-            "expected": 75.20
+           "description": "Three each of first 2 books and 2 each of remaining books",
+           "basket": [1,1,2,2,3,3,4,4,5,5,1,2],
+           "targetgrouping": [[1,2,3,4,5],[1,2,3,4,5],[1,2]],
+           "expected": 75.20
          }
-   ]
-}
+       ]
+       }
+  }
 }

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

@@ -0,0 +1,69 @@
+{
+  "transform": {
+    "#": [
+	"Note:  The expected input data for these tests should have",
+        "integer keys (not stringified numbers as shown in the JSON below",
+        "Unless the language prohibits that, please implement these tests",
+        "such that keys are integers. e.g. in JavaScript, it might look ",
+        "like `transform( { 1: ['A'] } );`"
+    ],
+    "description": "transforms the a set of scrabble data previously indexed by the tile score to a set of data indexed by the tile letter",
+    "cases": [
+      {
+        "description": "a single letter",
+        "input": {
+          "1": ["A"]
+        },
+        "expected": {
+          "a" : 1
+        }
+      },
+      {
+        "description": "single score with multiple letters",
+        "input": {
+          "1": ["A", "E", "I", "O", "U" ]
+        },
+        "expected": {
+          "a" : 1,
+          "e" : 1,
+          "i" : 1,
+          "o" : 1,
+          "u" : 1
+        }
+      },
+      {
+        "description": "multiple scores with multiple letters",
+        "input": {
+          "1": ["A", "E"],
+          "2": ["D", "G"]
+        },
+        "expected": {
+          "a" : 1,
+          "e" : 1,
+          "d" : 2,
+          "g" : 2
+        }
+      },
+      {
+        "description": "multiple scores with differing numbers of letters",
+        "input": {
+          "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" ]
+        },
+        "expected": {
+          "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
+        }
+      }
+    ]
+  }
+}

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.6.22"
+  VERSION = "2.0.6.23"
 end

data/tracks/go/config.json

@@ -90,14 +90,20 @@
       ]
     },
     {
-      "difficulty": 1,
+      "difficulty": 2,
       "slug": "pangram",
-      "topics": []
+      "topics": [
+        "Control-flow (loops)",
+        "Strings"
+      ]
     },
     {
-      "difficulty": 1,
+      "difficulty": 2,
       "slug": "bob",
-      "topics": []
+      "topics": [
+        "Control-flow (conditionals)",
+        "Strings"
+      ]
     },
     {
       "difficulty": 1,

data/tracks/java/config.json

@@ -57,7 +57,9 @@
     "twelve-days",
     "sublist",
     "rectangles",
-    "matrix"
+    "matrix",
+    "diamond",
+    "secret-handshake"
   ],
   "exercises": [
     {
@@ -329,6 +331,16 @@
       "slug": "matrix",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "diamond",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "secret-handshake",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

data/tracks/java/exercises/diamond/build.gradle

@@ -0,0 +1,17 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

data/tracks/java/exercises/diamond/src/example/java/DiamondPrinter.java

@@ -0,0 +1,41 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+final class DiamondPrinter {
+
+    private static final int A_INT = (int) 'A';
+
+    private static String blank(final int length) {
+        return String.join("", Collections.nCopies(length, " "));
+    }
+
+    private static String reverse(final String string) {
+        return new StringBuilder(string).reverse().toString();
+    }
+
+    List<String> printToList(final char chr) {
+        final int nRows = 2 * ((int) chr - A_INT) + 1;
+
+        final List<String> topRows = new ArrayList<>();
+
+        // Populate the top rows.
+        for (int nRow = 0; nRow < (nRows + 1) / 2; nRow++) {
+            final char rowChr = (char) (A_INT + nRow);
+
+            final String leftHalfOfRow  = blank((nRows - 1) / 2 - nRow) + rowChr + blank(nRow);
+            final String rightHalfOfRow = reverse(leftHalfOfRow.substring(0, leftHalfOfRow.length() - 1));
+            final String fullRow        = leftHalfOfRow + rightHalfOfRow;
+
+            topRows.add(fullRow);
+        }
+
+        // Populate the bottom rows by 'reflecting' the top rows.
+        for (int nRow = (nRows - 1) / 2 - 1; nRow >= 0; nRow--) {
+            topRows.add(topRows.get(nRow));
+        }
+
+        return topRows;
+    }
+
+}

data/tracks/java/exercises/diamond/src/main/java/DiamondPrinter.java

@@ -0,0 +1,5 @@
+final class DiamondPrinter {
+
+
+
+}

data/tracks/java/exercises/diamond/src/test/java/DiamondPrinterTest.java

@@ -0,0 +1,111 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+public final class DiamondPrinterTest {
+
+    @Test
+    public void testOneByOneDiamond() {
+        List<String> output = new DiamondPrinter().printToList('A');
+        assertThat(output, is(singletonList("A")));
+    }
+
+    @Ignore
+    @Test
+    public void testTwoByTwoDiamond() {
+        List<String> output = new DiamondPrinter().printToList('B');
+        assertThat(output, is(asList(" A ",
+                                     "B B",
+                                     " A ")));
+    }
+
+    @Ignore
+    @Test
+    public void testThreeByThreeDiamond() {
+        List<String> output = new DiamondPrinter().printToList('C');
+        assertThat(output, is(asList("  A  ",
+                                     " B B ",
+                                     "C   C",
+                                     " B B ",
+                                     "  A  ")));
+    }
+
+    @Ignore
+    @Test
+    public void testFiveByFiveDiamond() {
+        List<String> output = new DiamondPrinter().printToList('E');
+        assertThat(output, is(asList("    A    ",
+                                     "   B B   ",
+                                     "  C   C  ",
+                                     " D     D ",
+                                     "E       E",
+                                     " D     D ",
+                                     "  C   C  ",
+                                     "   B B   ",
+                                     "    A    ")));
+    }
+
+    @Ignore
+    @Test
+    public void testFullDiamond() {
+        List<String> output = new DiamondPrinter().printToList('Z');
+        assertThat(output, is(asList("                         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                         ")));
+    }
+
+}