trackler 2.0.1.1 → 2.0.1.2

data/tracks/crystal/src/generator/exercises/binary.cr

@@ -16,16 +16,16 @@ end
 class BinaryTestCase < ExerciseTestCase
   private getter binary : JSON::Any
   private getter description : JSON::Any
-  private getter expected : JSON::Any
+  private getter expected : JSON::Any?
 
   def initialize(test_case)
     @binary = test_case["binary"]
     @description = test_case["description"]
-    @expected = test_case["expected"]
+    @expected = test_case["expected"]?
   end
 
   def workload
-    if !(expected == nil)
+    if expected
       "Binary.to_decimal(\"#{binary}\").should eq(#{expected})"
     else
       <<-WL

data/tracks/crystal/src/generator/exercises/forth.cr

@@ -22,16 +22,16 @@ end
 class ForthTestCase < ExerciseTestCase
   private getter input : JSON::Any | String
   private getter description : JSON::Any
-  private getter expected : JSON::Any
+  private getter expected : JSON::Any?
 
   def initialize(test_case)
     @input = test_case["input"].as_a.join
     @description = test_case["description"]
-    @expected = fix_empty_array(test_case["expected"])
+    @expected = fix_empty_array(test_case["expected"]?)
   end
 
   def workload
-    if !(expected == nil)
+    if expected
       "Forth.evaluate(#{input.inspect}).should eq(#{expected})"
     else
       <<-WL

data/tracks/crystal/src/generator/exercises/hello_world.cr

@@ -15,7 +15,7 @@ end
 
 class HelloWorldTestCase < ExerciseTestCase
   private getter description : JSON::Any
-  private getter name : JSON::Any | Nil
+  private getter name : JSON::Any?
   private getter expected : JSON::Any
 
   def initialize(test_case)

data/tracks/haskell/exercises/bob/test/Tests.hs

@@ -15,7 +15,7 @@ specs = describe "bob" $
   where
     test Case{..} = it description $ responseFor input `shouldBe` expected
 
--- Test cases adapted from `exercism/x-common/bob.json` on 2016-07-24.
+-- Test cases adapted from `exercism/x-common/bob.json` on 2016-11-29.
 
 data Case = Case { description :: String
                  , input       :: String
@@ -75,14 +75,6 @@ cases = [ Case { description = "stating something"
                , input       = "ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!"
                , expected    = "Whoa, chill out!"
                }
-        , Case { description = "shouting with umlauts"
-               , input       = "ÜMLÄÜTS!"
-               , expected    = "Whoa, chill out!"
-               }
-        , Case { description = "calmly speaking with umlauts"
-               , input       = "ÜMLäÜTS!"
-               , expected    = "Whatever."
-               }
         , Case { description = "shouting with no exclamation mark"
                , input       = "I HATE YOU"
                , expected    = "Whoa, chill out!"
@@ -124,7 +116,7 @@ cases = [ Case { description = "stating something"
                , expected    = "Sure."
                }
         , Case { description = "other whitespace"
-               , input       = "\n\r \t\x000b\x00a0\x2002"
+               , input       = "\n\r \t"
                , expected    = "Fine. Be that way!"
                }
         , Case { description = "non-question ending with whitespace"

data/tracks/haskell/exercises/sublist/test/Tests.hs

@@ -42,7 +42,7 @@ specs = describe "sublist" $ do
                               , "-"
                               , description ]
 
--- Test cases adapted from `exercism/x-common/sublist.json` on 2016-07-27.
+-- Test cases adapted from `exercism/x-common/sublist.json` on 2016-11-29.
 
 data Case = Case { description :: String
                  , listOne     :: [Integer]
@@ -131,4 +131,9 @@ cases = [ Case { description = "empty lists"
                , listTwo     = [3, 2, 1]
                , expectation = Unequal
                }
+        , Case { description = "same digits but different numbers"
+               , listOne     = [1, 0, 1]
+               , listTwo     = [10, 1]
+               , expectation = Unequal
+               }
         ]

data/tracks/java/config.json

@@ -48,7 +48,9 @@
     "largest-series-product",
     "queen-attack",
     "minesweeper",
-    "series"
+    "series",
+    "robot-simulator",
+    "bracket-push"
   ],
   "exercises": [
     {
@@ -275,6 +277,16 @@
       "slug": "series",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "robot-simulator",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "bracket-push",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

data/tracks/java/exercises/bracket-push/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/bracket-push/src/example/java/BracketChecker.java

@@ -0,0 +1,45 @@
+import java.util.*;
+
+final class BracketChecker {
+
+    private static final Map<Character, Character> BRACKET_PAIR_MAP = new HashMap<Character, Character>() {{
+        put('[', ']');
+        put('{', '}');
+        put('(', ')');
+    }};
+
+    private static boolean isOpeningBracket(final char character) {
+        return BRACKET_PAIR_MAP.keySet().contains(character);
+    }
+
+    private static boolean isClosingBracket(final char character) {
+        return BRACKET_PAIR_MAP.values().contains(character);
+    }
+
+    private final String expression;
+
+    BracketChecker(final String expression) {
+        this.expression = expression;
+    }
+
+    boolean areBracketsMatchedAndNestedCorrectly() {
+        final Stack<Character> bracketsStack = new Stack<>();
+
+        for (final char character : expression.toCharArray()) {
+            if (isOpeningBracket(character)) {
+                bracketsStack.push(character);
+            } else if (isClosingBracket(character)) {
+                if (bracketsStack.isEmpty()) {
+                    return false;
+                }
+
+                if (!BRACKET_PAIR_MAP.get(bracketsStack.pop()).equals(character)) {
+                    return false;
+                }
+            }
+        }
+
+        return bracketsStack.isEmpty();
+    }
+
+}

data/tracks/java/exercises/bracket-push/src/main/java/BracketChecker.java

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

data/tracks/java/exercises/bracket-push/src/test/java/BracketCheckerTest.java

@@ -0,0 +1,102 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public final class BracketCheckerTest {
+
+    @Test
+    public void testPairedSquareBrackets() {
+        final BracketChecker bracketChecker = new BracketChecker("[]");
+        assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+    @Ignore
+    @Test
+    public void testEmptyString() {
+        final BracketChecker bracketChecker = new BracketChecker("");
+        assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+    @Ignore
+    @Test
+    public void testUnpairedBrackets() {
+        final BracketChecker bracketChecker = new BracketChecker("[[");
+        assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+    @Ignore
+    @Test
+    public void testIncorrectlyOrderedBrackets() {
+        final BracketChecker bracketChecker = new BracketChecker("}{");
+        assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+    @Ignore
+    @Test
+    public void testPairedBracketsWithWhitespace() {
+        final BracketChecker bracketChecker = new BracketChecker("{ }");
+        assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+    @Ignore
+    @Test
+    public void testSimpleNestedBrackets() {
+        final BracketChecker bracketChecker = new BracketChecker("{[]}");
+        assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+    @Ignore
+    @Test
+    public void testSeveralPairedBrackets() {
+        final BracketChecker bracketChecker = new BracketChecker("{}[]");
+        assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+    @Ignore
+    @Test
+    public void testPairedAndNestedBrackets() {
+        final BracketChecker bracketChecker = new BracketChecker("([{}({}[])])");
+        assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+    @Ignore
+    @Test
+    public void testUnopenedClosingBracket() {
+        final BracketChecker bracketChecker = new BracketChecker("{[)][]}");
+        assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+    @Ignore
+    @Test
+    public void testUnpairedAndNestedBracket() {
+        final BracketChecker bracketChecker = new BracketChecker("([{])");
+        assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+    @Ignore
+    @Test
+    public void testPairedAndIncorrectlyNestedBrackets() {
+        final BracketChecker bracketChecker = new BracketChecker("[({]})");
+        assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+    @Ignore
+    @Test
+    public void testValidMathExpression() {
+        final BracketChecker bracketChecker = new BracketChecker("(((185 + 223.85) * 15) - 543)/2");
+        assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+    @Ignore
+    @Test
+    public void testValidComplexLaTeXExpression() {
+        final BracketChecker bracketChecker = new BracketChecker(
+                "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)");
+
+        assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
+    }
+
+}

data/tracks/java/exercises/robot-simulator/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/robot-simulator/src/example/java/GridPosition.java

@@ -0,0 +1 @@
+tracks/java/exercises/robot-simulator/src/example/java/../../main/java/GridPosition.java

data/tracks/java/exercises/robot-simulator/src/example/java/Orientation.java

@@ -0,0 +1 @@
+tracks/java/exercises/robot-simulator/src/example/java/../../main/java/Orientation.java

data/tracks/java/exercises/robot-simulator/src/example/java/Robot.java

@@ -0,0 +1,71 @@
+final class Robot {
+
+    private GridPosition gridPosition;
+
+    private Orientation orientation;
+
+    Robot(final GridPosition initialGridPosition, final Orientation initialOrientation) {
+        this.gridPosition = initialGridPosition;
+        this.orientation = initialOrientation;
+    }
+
+    GridPosition getGridPosition() {
+        return gridPosition;
+    }
+
+    Orientation getOrientation() {
+        return orientation;
+    }
+
+    Robot advance() {
+        switch (orientation) {
+            case NORTH:
+                gridPosition = new GridPosition(gridPosition.x, gridPosition.y + 1);
+                break;
+            case EAST:
+                gridPosition = new GridPosition(gridPosition.x + 1, gridPosition.y);
+                break;
+            case SOUTH:
+                gridPosition = new GridPosition(gridPosition.x, gridPosition.y - 1);
+                break;
+            case WEST:
+                gridPosition = new GridPosition(gridPosition.x - 1, gridPosition.y);
+                break;
+        }
+
+        return this;
+    }
+
+    Robot simulate(final String instructions) {
+        for (final char instruction : instructions.toCharArray()) {
+            switch (instruction) {
+                case 'A':
+                    advance();
+                    break;
+                case 'R':
+                    turnRight();
+                    break;
+                case 'L':
+                    turnLeft();
+                    break;
+                default:
+                    throw new IllegalArgumentException(String.format("Invalid instruction: '%s'", instruction));
+            }
+        }
+
+        return this;
+    }
+
+    Robot turnLeft() {
+        final int newOrientationOrdinal = Math.floorMod(orientation.ordinal() - 1, Orientation.values().length);
+        orientation = Orientation.values()[newOrientationOrdinal];
+        return this;
+    }
+
+    Robot turnRight() {
+        final int newOrientationOrdinal = Math.floorMod(orientation.ordinal() + 1, Orientation.values().length);
+        orientation = Orientation.values()[newOrientationOrdinal];
+        return this;
+    }
+
+}

data/tracks/java/exercises/robot-simulator/src/main/java/GridPosition.java

@@ -0,0 +1,29 @@
+final class GridPosition {
+
+    final int x;
+
+    final int y;
+
+    GridPosition(final int x, final int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    /*
+     * This equals method is of deliberately narrow scope (only allows comparison with another GridPosition) to increase
+     * readability. In general, one should provide a full implementation of Object.equals(Object obj) and a
+     * corresponding implementation of Object.hashCode(). See
+     *
+     * https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)
+     *
+     * and
+     *
+     * https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#hashCode()
+     *
+     * for more information.
+     */
+    boolean equals(final GridPosition gridPosition) {
+        return this.x == gridPosition.x && this.y == gridPosition.y;
+    }
+
+}

data/tracks/java/exercises/robot-simulator/src/main/java/Orientation.java

@@ -0,0 +1,5 @@
+enum Orientation {
+
+    NORTH, EAST, SOUTH, WEST
+
+}

data/tracks/java/exercises/robot-simulator/src/main/java/Robot.java

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