trackler 2.0.0.8 → 2.0.0.9

data/tracks/haskell/exercises/sieve/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/haskell/exercises/simple-cipher/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/haskell/exercises/simple-linked-list/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/haskell/exercises/space-age/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/haskell/exercises/strain/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/haskell/exercises/sublist/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/haskell/exercises/sum-of-multiples/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/haskell/exercises/triangle/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/haskell/exercises/trinary/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/haskell/exercises/word-count/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/haskell/exercises/wordy/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/haskell/exercises/zebra-puzzle/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/haskell/exercises/zipper/stack.yaml

@@ -1 +1 @@
-resolver: nightly-2016-07-17
+resolver: lts-7.9

data/tracks/java/config.json

@@ -45,7 +45,9 @@
     "beer-song",
     "difference-of-squares",
     "largest-series-product",
-    "queen-attack"
+    "queen-attack",
+    "minesweeper",
+    "series"
   ],
   "exercises": [
     {
@@ -257,6 +259,16 @@
       "slug": "queen-attack",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "minesweeper",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "series",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

data/tracks/java/exercises/etl/src/main/java/Etl.java

@@ -2,7 +2,7 @@ import java.util.List;
 import java.util.Map;
 
 public class Etl {
-   public Map<String, Integer> transform(Map<Integer, List<String>> old) {
-      return null;
-   }
+    public Map<String, Integer> transform(Map<Integer, List<String>> old) {
+        return null;
+    }
 }

data/tracks/java/exercises/hello-world/GETTING_STARTED.md

@@ -20,7 +20,7 @@ $ gradle test
 
 ## Iterate through the tests
 
-After your first test passes, remove the `@Ignore` from the next test, and ierate on your solution,
+After your first test passes, remove the `@Ignore` from the next test, and iterate on your solution,
 testing after each change.
 
 ## All the tests pass?  Submit your solution!

data/tracks/java/exercises/hello-world/src/main/java/HelloWorld.java

@@ -1,5 +1,5 @@
 public class HelloWorld {
-	public static String hello(String name) {
-      return null;
-	}
+    public static String hello(String name) {
+        return null;
+    }
 }

data/tracks/java/exercises/minesweeper/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/minesweeper/src/example/java/MinesweeperBoard.java

@@ -0,0 +1,111 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+final class MinesweeperBoard {
+
+    private static final char MINE_CHAR = '*';
+
+    private static final char SPACE_CHAR = ' ';
+
+    private final List<String> rawRepresentation;
+
+    private final int numberOfRows;
+
+    private final int numberOfColumns;
+
+    MinesweeperBoard(final List<String> rawRepresentation) {
+        validateInputBoard(rawRepresentation);
+        this.rawRepresentation = rawRepresentation;
+        this.numberOfRows = rawRepresentation.size();
+        this.numberOfColumns = rawRepresentation.isEmpty() ? 0 : rawRepresentation.get(0).length();
+    }
+
+    List<String> getAnnotatedRepresentation() throws IllegalArgumentException {
+        final List<String> result = new ArrayList<>();
+
+        for (int rowNumber = 0; rowNumber < numberOfRows; rowNumber++) {
+            result.add(getAnnotatedRow(rowNumber));
+        }
+
+        return result;
+    }
+
+    private String getAnnotatedRow(final int rowNumber) {
+        String result = "";
+
+        for (int columnNumber = 0; columnNumber < numberOfColumns; columnNumber++) {
+            result += getCellAnnotation(rowNumber, columnNumber);
+        }
+
+        return result;
+    }
+
+    private char getCellAnnotation(final int rowNumber, final int columnNumber) {
+        // If (rowNumber, columnNumber) is a mine, we're done.
+        if (rawRepresentation.get(rowNumber).charAt(columnNumber) == MINE_CHAR) {
+            return MINE_CHAR;
+        }
+
+        final int mineCount = computeMineCountAround(rowNumber, columnNumber);
+
+        // If computed count is positive, add it to the annotated row. Otherwise, add a blank space.
+        return mineCount > 0 ? Character.forDigit(mineCount, 10) : SPACE_CHAR;
+    }
+
+    private int computeMineCountAround(final int rowNumber, final int columnNumber) {
+        int result = 0;
+
+        // Compute row and column ranges to inspect (respecting board edges).
+        final int minRowToInspect = Math.max(rowNumber - 1, 0);
+        final int maxRowToInspect = Math.min(rowNumber + 1, numberOfRows - 1);
+        final int minColToInspect = Math.max(columnNumber - 1, 0);
+        final int maxColToInspect = Math.min(columnNumber + 1, numberOfColumns - 1);
+
+        // Count mines in the cells surrounding (row, col).
+        for (int rowToInspect = minRowToInspect; rowToInspect <= maxRowToInspect; rowToInspect++) {
+            for (int colToInspect = minColToInspect; colToInspect <= maxColToInspect; colToInspect++) {
+                if (rawRepresentation.get(rowToInspect).charAt(colToInspect) == MINE_CHAR) {
+                    result += 1;
+                }
+            }
+        }
+
+        return result;
+    }
+
+    private void validateInputBoard(final List<String> inputBoard) throws IllegalArgumentException {
+        validateInputBoardIsNotNull(inputBoard);
+
+        if (inputBoard.isEmpty()) {
+            return;
+        }
+
+        validateInputBoardCharacters(inputBoard);
+        validateInputBoardColumnCounts(inputBoard);
+    }
+
+    private void validateInputBoardIsNotNull(final List<String> inputBoard) throws IllegalArgumentException {
+        if (inputBoard == null) {
+            throw new IllegalArgumentException("Input board may not be null.");
+        }
+    }
+
+    private void validateInputBoardCharacters(final List<String> inputBoard) throws IllegalArgumentException {
+        final String allBoardCharacters = String.join("", inputBoard);
+
+        if (!allBoardCharacters.matches("^[ *]*$")) {
+            throw new IllegalArgumentException("Input board can only contain the characters ' ' and '*'.");
+        }
+    }
+
+    private void validateInputBoardColumnCounts(final List<String> inputBoard) throws IllegalArgumentException {
+        final Set<Integer> setOfColumnCounts = inputBoard.stream().map(String::length).collect(Collectors.toSet());
+
+        if (setOfColumnCounts.size() > 1) {
+            throw new IllegalArgumentException("Input board rows must all have the same number of columns.");
+        }
+    }
+
+}

data/tracks/java/exercises/minesweeper/src/main/java/MinesweeperBoard.java

@@ -0,0 +1,5 @@
+public final class MinesweeperBoard {
+
+
+
+}

data/tracks/java/exercises/minesweeper/src/test/java/MinesweeperBoardTest.java

@@ -0,0 +1,295 @@
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public final class MinesweeperBoardTest {
+
+    /*
+     * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and
+     * ExpectedExceptions in particular.
+     */
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Test
+    public void testInputBoardWithNoRowsAndNoColumns() {
+        final List<String> inputBoard = Collections.emptyList();
+        final List<String> expectedAnnotatedRepresentation = Collections.emptyList();
+        final List<String> actualAnnotatedRepresentation
+                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+
+        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+    }
+
+    @Ignore
+    @Test
+    public void testInputBoardWithOneRowAndNoColumns() {
+        final List<String> inputBoard = Collections.singletonList("");
+        final List<String> expectedAnnotatedRepresentation = Collections.singletonList("");
+        final List<String> actualAnnotatedRepresentation
+                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+
+        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+    }
+
+    @Ignore
+    @Test
+    public void testInputBoardWithNoMines() {
+        final List<String> inputBoard = Arrays.asList(
+                "   ",
+                "   ",
+                "   "
+        );
+
+        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+                "   ",
+                "   ",
+                "   "
+        );
+
+        final List<String> actualAnnotatedRepresentation
+                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+
+        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+    }
+
+    @Ignore
+    @Test
+    public void testInputBoardWithOnlyMines() {
+        final List<String> inputBoard = Arrays.asList(
+                "***",
+                "***",
+                "***"
+        );
+
+        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+                "***",
+                "***",
+                "***"
+        );
+
+        final List<String> actualAnnotatedRepresentation
+                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+
+        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+    }
+
+    @Ignore
+    @Test
+    public void testInputBoardWithSingleMineAtCenter() {
+        final List<String> inputBoard = Arrays.asList(
+                "   ",
+                " * ",
+                "   "
+        );
+
+        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+                "111",
+                "1*1",
+                "111"
+        );
+
+        final List<String> actualAnnotatedRepresentation
+                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+
+        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+    }
+
+    @Ignore
+    @Test
+    public void testInputBoardWithMinesAroundPerimeter() {
+        final List<String> inputBoard = Arrays.asList(
+                "***",
+                "* *",
+                "***"
+        );
+
+        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+                "***",
+                "*8*",
+                "***"
+        );
+
+        final List<String> actualAnnotatedRepresentation
+                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+
+        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+    }
+
+    @Ignore
+    @Test
+    public void testInputBoardWithSingleRowAndTwoMines() {
+        final List<String> inputBoard = Collections.singletonList(
+                " * * "
+        );
+
+        final List<String> expectedAnnotatedRepresentation = Collections.singletonList(
+                "1*2*1"
+        );
+
+        final List<String> actualAnnotatedRepresentation
+                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+
+        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+    }
+
+    @Ignore
+    @Test
+    public void testInputBoardWithSingleRowAndTwoMinesAtEdges() {
+        final List<String> inputBoard = Collections.singletonList(
+                "*   *"
+        );
+
+        final List<String> expectedAnnotatedRepresentation = Collections.singletonList(
+                "*1 1*"
+        );
+
+        final List<String> actualAnnotatedRepresentation
+                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+
+        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+    }
+
+    @Ignore
+    @Test
+    public void testInputBoardWithSingleColumnAndTwoMines() {
+        final List<String> inputBoard = Arrays.asList(
+                " ",
+                "*",
+                " ",
+                "*",
+                " "
+        );
+
+        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+                "1",
+                "*",
+                "2",
+                "*",
+                "1"
+        );
+
+        final List<String> actualAnnotatedRepresentation
+                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+
+        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+    }
+
+    @Ignore
+    @Test
+    public void testInputBoardWithSingleColumnAndTwoMinesAtEdges() {
+        final List<String> inputBoard = Arrays.asList(
+                "*",
+                " ",
+                " ",
+                " ",
+                "*"
+        );
+
+        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+                "*",
+                "1",
+                " ",
+                "1",
+                "*"
+        );
+
+        final List<String> actualAnnotatedRepresentation
+                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+
+        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+    }
+
+    @Ignore
+    @Test
+    public void testInputBoardWithMinesInCross() {
+        final List<String> inputBoard = Arrays.asList(
+                "  *  ",
+                "  *  ",
+                "*****",
+                "  *  ",
+                "  *  "
+        );
+
+        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+                " 2*2 ",
+                "25*52",
+                "*****",
+                "25*52",
+                " 2*2 "
+        );
+
+        final List<String> actualAnnotatedRepresentation
+                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+
+        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+    }
+
+    @Ignore
+    @Test
+    public void testLargeInputBoard() {
+        final List<String> inputBoard = Arrays.asList(
+                " *  * ",
+                "  *   ",
+                "    * ",
+                "   * *",
+                " *  * ",
+                "      "
+        );
+
+        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+                "1*22*1",
+                "12*322",
+                " 123*2",
+                "112*4*",
+                "1*22*2",
+                "111111"
+        );
+
+        final List<String> actualAnnotatedRepresentation
+                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+
+        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+    }
+
+    @Ignore
+    @Test
+    public void testNullInputBoardIsRejected() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Input board may not be null.");
+
+        new MinesweeperBoard(null);
+    }
+
+    @Ignore
+    @Test
+    public void testInputBoardWithInvalidSymbolsIsRejected() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Input board can only contain the characters ' ' and '*'.");
+
+        new MinesweeperBoard(Collections.singletonList(" * & "));
+    }
+
+    @Ignore
+    @Test
+    public void testInputBoardWithInconsistentRowLengthsIsRejected() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Input board rows must all have the same number of columns.");
+
+        new MinesweeperBoard(Arrays.asList(
+                "*",
+                "**",
+                "* *",
+                "*  *",
+                "*   *"
+        ));
+    }
+
+}