diamond: add to track (#256)

config.json

     "twelve-days",
     "sublist",
     "rectangles",
-    "matrix"
+    "matrix",
+    "diamond"
   ],
   "exercises": [
     {
       "slug": "matrix",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "diamond",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

exercises/diamond/build.gradle

+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"]
+  }
+}

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

+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;
+    }
+
+}

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

+final class DiamondPrinter {
+
+
+
+}

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

+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                         ")));
+    }
+
+}

exercises/settings.gradle

 include 'bracket-push'
 include 'crypto-square'
 include 'custom-set'
+include 'diamond'
 include 'difference-of-squares'
 include 'etl'
 include 'gigasecond'