Merge pull request #522 from Smarticles101/run-length-encoding

run-length-encoding: add to track

config.json

@@ -329,6 +329,11 @@
       "slug": "saddle-points",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "run-length-encoding",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

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

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

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

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