trackler 2.1.0.11 → 2.1.0.12

data/tracks/java/exercises/difference-of-squares/src/example/java/DifferenceOfSquaresCalculator.java

@@ -1,19 +1,19 @@
 import java.util.stream.IntStream;
 
-public final class DifferenceOfSquaresCalculator {
+final class DifferenceOfSquaresCalculator {
 
-    public int computeSquareOfSumTo(final int input) {
+    int computeSquareOfSumTo(final int input) {
         final int sum = input * (input + 1) / 2;
         return (int) Math.pow(sum, 2);
     }
 
-    public int computeSumOfSquaresTo(final int input) {
+    int computeSumOfSquaresTo(final int input) {
         return IntStream.rangeClosed(1, input)
                 .map(i -> (int) Math.pow(i, 2))
                 .sum();
     }
 
-    public int computeDifferenceOfSquares(final int input) {
+    int computeDifferenceOfSquares(final int input) {
         return computeSquareOfSumTo(input) - computeSumOfSquaresTo(input);
     }
 

data/tracks/java/exercises/difference-of-squares/src/main/java/DifferenceOfSquaresCalculator.java

@@ -1,5 +1,15 @@
-public final class DifferenceOfSquaresCalculator {
+final class DifferenceOfSquaresCalculator {
 
+    int computeSquareOfSumTo(final int input) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
 
+    int computeSumOfSquaresTo(final int input) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    int computeDifferenceOfSquares(final int input) {
+      throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
 
 }

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;
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 }

data/tracks/java/exercises/pangram/src/main/java/PangramChecker.java

@@ -1,6 +1,7 @@
 public class PangramChecker {
 
     public boolean isPangram(String input) {
-        throw new UnsupportedOperationException("Method has not been implemented yet.");
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
+
 }

data/tracks/java/exercises/raindrops/src/example/java/RaindropConverter.java

@@ -1,6 +1,6 @@
-public class RaindropConverter {
+class RaindropConverter {
 
-    public String convert(int number) {
+    String convert(int number) {
         String result = "";
 
         if (number % 3 == 0) {
@@ -15,10 +15,11 @@ public class RaindropConverter {
             result += "Plong";
         }
 
-        if (result == null || result.isEmpty()) {
+        if (result.isEmpty()) {
             result = Integer.toString(number);
         }
 
         return result;
     }
+
 }

data/tracks/java/exercises/raindrops/src/main/java/RaindropConverter.java

@@ -0,0 +1,7 @@
+class RaindropConverter {
+
+    String convert(int number) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/java/exercises/rna-transcription/src/example/java/RnaTranscription.java

@@ -1,8 +1,8 @@
 public class RnaTranscription {
 
-    public String ofDna(String strand) {
+    public String transcribe(String dnaStrand) {
         StringBuilder sb = new StringBuilder();
-        for (char c : strand.toCharArray()) {
+        for (char c : dnaStrand.toCharArray()) {
             switch (c) {
                 case 'A':
                     sb.append('U');

data/tracks/java/exercises/rna-transcription/src/main/java/RnaTranscription.java

@@ -1,5 +1,5 @@
 public class RnaTranscription {
-    public String ofDna(String dnaString) {
-        throw new UnsupportedOperationException("Method has not been implemented yet.");
+    public String transcribe(String dnaStrand) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 }

data/tracks/java/exercises/rna-transcription/src/test/java/RnaTranscriptionTest.java

@@ -14,36 +14,36 @@ public class RnaTranscriptionTest {
 
     @Test
     public void testRnaTranscriptionOfEmptyDnaIsEmptyRna() {
-        Assert.assertEquals("", rnaTranscription.ofDna(""));
+        Assert.assertEquals("", rnaTranscription.transcribe(""));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testRnaTranscriptionOfCytosineIsGuanine() {
-        Assert.assertEquals("G", rnaTranscription.ofDna("C"));
+        Assert.assertEquals("G", rnaTranscription.transcribe("C"));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testRnaTranscriptionOfGuanineIsCytosine() {
-        Assert.assertEquals("C", rnaTranscription.ofDna("G"));
+        Assert.assertEquals("C", rnaTranscription.transcribe("G"));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testRnaTranscriptionOfThymineIsAdenine() {
-        Assert.assertEquals("A", rnaTranscription.ofDna("T"));
+        Assert.assertEquals("A", rnaTranscription.transcribe("T"));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testRnaTranscriptionOfAdenineIsUracil() {
-        Assert.assertEquals("U", rnaTranscription.ofDna("A"));
+        Assert.assertEquals("U", rnaTranscription.transcribe("A"));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testRnaTranscription() {
-        Assert.assertEquals("UGCACCAGAAUU", rnaTranscription.ofDna("ACGTGGTCTTAA"));
+        Assert.assertEquals("UGCACCAGAAUU", rnaTranscription.transcribe("ACGTGGTCTTAA"));
     }
 }

data/tracks/java/exercises/run-length-encoding/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/run-length-encoding/src/example/java/RunLengthEncoding.java

@@ -0,0 +1,67 @@
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class RunLengthEncoding {
+    public String encode(String data) {
+
+        StringBuilder encodedDataBuilder = new StringBuilder();
+
+        if (data.length() == 0) {
+            return data;
+        }
+
+        int previousCharCount = 1;
+        char previousChar = data.charAt(0);
+
+        for (int i = 1; i < data.length(); i++) {
+            char currentChar = data.charAt(i);
+
+            if (previousChar == currentChar) {
+                previousCharCount++;
+            }
+
+            if (previousChar != currentChar || i == data.length() - 1) {
+                addChars(encodedDataBuilder, previousChar, previousCharCount);
+
+                if (previousChar != currentChar && i == data.length() - 1) {
+                    addChars(encodedDataBuilder, currentChar, 1);
+                }
+
+                previousChar = currentChar;
+                previousCharCount = 1;
+            }
+        }
+
+        return encodedDataBuilder.toString();
+    }
+
+    public void addChars(StringBuilder toAddTo, char toAdd, int countOfChar) {
+        if(countOfChar != 1) {
+            toAddTo.append(countOfChar);
+        }
+
+        toAddTo.append(toAdd);
+    }
+
+    public String decode(String encodedData) {
+        StringBuilder decodedData = new StringBuilder();
+        Pattern pattern = Pattern.compile("[0-9]+|[a-zA-Z\\s]");
+        Matcher matcher = pattern.matcher(encodedData);
+
+        while (matcher.find()) {
+            try {
+                int number = Integer.parseInt(matcher.group());
+
+                matcher.find();
+
+                for (int i = 0; i<number; i++) {
+                    decodedData.append(matcher.group());
+                }
+            } catch (NumberFormatException e) {
+                decodedData.append(matcher.group());
+            }
+        }
+
+        return decodedData.toString();
+    }
+}

data/tracks/java/exercises/run-length-encoding/src/main/java/RunLengthEncoding.java

@@ -0,0 +1,9 @@
+public class RunLengthEncoding {
+    public String encode(String data) {
+        throw new UnsupportedOperationException("Method has not been implemented yet.");
+    }
+
+    public String decode(String encodedData) {
+        throw new UnsupportedOperationException("Method has not been implemented yet.");
+    }
+}

data/tracks/java/exercises/run-length-encoding/src/test/java/RunLengthEncodingTest.java

@@ -0,0 +1,111 @@
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class RunLengthEncodingTest {
+    private RunLengthEncoding runLengthEncoding;
+
+    @Before
+    public void setUp() {
+        runLengthEncoding = new RunLengthEncoding();
+    }
+
+    @Test
+    public void encodeEmpty() {
+        Assert.assertEquals("", runLengthEncoding.encode(""));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void encodeWithOnlySingleValues() {
+        Assert.assertEquals("XYZ", runLengthEncoding.encode("XYZ"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void encodeWithNoSingleValues() {
+        Assert.assertEquals(
+                "2A3B4C",
+                runLengthEncoding.encode("AABBBCCCC"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void encodeWithMixedValues() {
+        Assert.assertEquals(
+                "12WB12W3B24WB",
+                runLengthEncoding.encode(
+                        "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void encodeWithWhitespaceValues() {
+        Assert.assertEquals(
+                "2 hs2q q2w2 ",
+                runLengthEncoding.encode("  hsqq qww  "));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void encodeWithLowercaseValues() {
+        Assert.assertEquals(
+                "2a3b4c",
+                runLengthEncoding.encode("aabbbcccc"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void decodeEmpty() {
+        Assert.assertEquals("", runLengthEncoding.decode(""));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void decodeWithOnlySingleValues() {
+        Assert.assertEquals(
+                "XYZ",
+                runLengthEncoding.decode("XYZ"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void decodeWithNoSingleValues() {
+        Assert.assertEquals(
+                "AABBBCCCC",
+                runLengthEncoding.decode("2A3B4C"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void decodeWithMixedValues() {
+        Assert.assertEquals(
+                "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB",
+                runLengthEncoding.decode("12WB12W3B24WB"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void decodeWithWhitespaceValues() {
+        Assert.assertEquals(
+                "  hsqq qww  ",
+                runLengthEncoding.decode("2 hs2q q2w2 "));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void decodeWithLowercaseValues() {
+        Assert.assertEquals(
+                "aabbbcccc",
+                runLengthEncoding.decode("2a3b4c"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void encodeThenDecode() {
+        String inOut = "zzz ZZ  zZ";
+        String encoded = runLengthEncoding.encode(inOut);
+        Assert.assertEquals(inOut, runLengthEncoding.decode(encoded));
+    }
+}

data/tracks/java/exercises/scrabble-score/src/example/java/Scrabble.java

@@ -1,7 +1,7 @@
 import java.util.Map;
 import java.util.HashMap;
 
-public class Scrabble {
+final class Scrabble {
 
     private String word;
 
@@ -36,17 +36,15 @@ public class Scrabble {
         letterScores.put('z', 10);
     }
 
-    private Object score;
-
-    public Scrabble(String word) {
+    Scrabble(String word) {
         this.word = word;
     }
 
-    public int getScore() {
+    int getScore() {
         return getScore(word);
     }
 
-    public static int getScore(String input) {
+    private static int getScore(String input) {
         if (input == null || input.trim().isEmpty()) {
             return 0;
         }
@@ -59,4 +57,5 @@ public class Scrabble {
 
         return score;
     }
+
 }

data/tracks/java/exercises/scrabble-score/src/main/java/Scrabble.java

@@ -0,0 +1,11 @@
+final class Scrabble {
+
+    Scrabble(String word) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    int getScore() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/java/exercises/scrabble-score/src/test/java/ScrabbleScoreTest.java

@@ -1,5 +1,4 @@
 import org.junit.Test;
-import org.junit.Ignore;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
@@ -34,11 +33,10 @@ public class ScrabbleScoreTest {
         this.scrabbleScore = scrabbleScore;
     }
 
-
     @Test
     public void test() {
         Scrabble scrabble = new Scrabble(scrabbleInput);
-
         assertEquals(scrabbleScore, scrabble.getScore());
     }
+
 }

data/tracks/java/exercises/space-age/src/example/java/SpaceAge.java

@@ -1,6 +1,6 @@
 import java.math.BigDecimal;
 
-public class SpaceAge {
+class SpaceAge {
 
     private enum Planet {
         EARTH(1.0),
@@ -18,7 +18,7 @@ public class SpaceAge {
             this.relativeOrbitalPeriod = relativeOrbitalPeriod;
         }
 
-        public double getRelativeOrbitalPeriod() {
+        private double getRelativeOrbitalPeriod() {
             return relativeOrbitalPeriod;
         }
     }
@@ -28,43 +28,43 @@ public class SpaceAge {
 
     private double seconds;
 
-    public SpaceAge(double seconds) {
+    SpaceAge(double seconds) {
         this.seconds = seconds;
     }
 
-    public double getSeconds() {
+    double getSeconds() {
         return seconds;
     }
 
-    public double onEarth() {
+    double onEarth() {
         return calculateAge(Planet.EARTH);
     }
 
-    public double onMercury() {
+    double onMercury() {
         return calculateAge(Planet.MERCURY);
     }
 
-    public double onVenus() {
+    double onVenus() {
         return calculateAge(Planet.VENUS);
     }
 
-    public double onMars() {
+    double onMars() {
         return calculateAge(Planet.MARS);
     }
 
-    public double onJupiter() {
+    double onJupiter() {
         return calculateAge(Planet.JUPITER);
     }
 
-    public double onSaturn() {
+    double onSaturn() {
         return calculateAge(Planet.SATURN);
     }
 
-    public double onUranus() {
+    double onUranus() {
         return calculateAge(Planet.URANUS);
     }
 
-    public double onNeptune() {
+    double onNeptune() {
         return calculateAge(Planet.NEPTUNE);
     }
 
@@ -73,4 +73,5 @@ public class SpaceAge {
 
         return new BigDecimal(age).setScale(PRECISION, BigDecimal.ROUND_HALF_UP).doubleValue();
     }
+
 }