Add new exercise Variable Length Quantity (#1348)

* Add new exercise Variable Length Quantity

* Fix test file

* Get rid of unchecked/unsafe operations warning

* Fix typo in config.json

* Add List imoprt to starter solution

* Break up some tests into multiple lines

* Throw an IllegalArgumentException in error cases.

* Add more topics

* Indent multi-line arguments

config.json

@@ -434,6 +434,21 @@
       "uuid": "c3e89c7c-3a8a-4ddc-b653-9b0ff9e1d7d8"
     },
     {
+      "core": false,
+      "difficulty": 4,
+      "slug": "variable-length-quantity",
+      "topics": [
+        "bitwise_operations",
+        "conditionals",
+        "exception_handling",
+        "lists",
+        "loops",
+        "transforming"
+      ],
+      "unlocked_by": "secret-handshake",
+      "uuid": "d8a2c7ba-2040-4cfe-ab15-f90b3b61dd89"
+    },
+    {
       "core": true,
       "difficulty": 5,
       "slug": "flatten-array",

exercises/settings.gradle

@@ -94,6 +94,7 @@ include 'trinary'
 include 'twelve-days'
 include 'two-bucket'
 include 'two-fer'
+include 'variable-length-quantity'
 include 'word-count'
 include 'word-search'
 include 'wordy'

exercises/variable-length-quantity/.meta/src/reference/java/VariableLengthQuantity.java

@@ -0,0 +1,53 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+class VariableLengthQuantity {
+
+    private long sevenBitsMask = 0x7f;
+    private long eightBitsMask = 0x80;
+
+    List<String> encodeSingleNumber(long number) {
+        List<String> bytes = new ArrayList<String>();
+        bytes.add("0x" + Long.toHexString(number & sevenBitsMask));
+        number >>= 7;
+
+        while (number > 0) {
+            bytes.add("0x" + Long.toHexString(number & sevenBitsMask | eightBitsMask));
+            number >>= 7;
+        }
+
+        Collections.reverse(bytes);
+        return bytes;
+    }
+
+    List<String> encode(List<Long> numbers) {
+        List<String> bytes = new ArrayList<String>();
+        for (long number : numbers) {
+            bytes.addAll(encodeSingleNumber(number));
+        }
+
+        return bytes;
+    }
+
+    List<String> decode(List<Long> bytes) {
+        List<String> numbers = new ArrayList<String>();
+        int i = 0;
+        long number = 0;
+
+        for (long b : bytes) {
+            number <<= 7;
+            number += b & sevenBitsMask;
+
+            if ((b & eightBitsMask) == 0) {
+                numbers.add("0x" + Long.toHexString(number));
+                number = 0;
+                i++;
+            } else if (i == bytes.size() - 1) {
+                throw new IllegalArgumentException("Invalid variable-length quantity encoding");
+            }
+        }
+
+        return numbers;
+    }
+}

exercises/variable-length-quantity/.meta/version

@@ -0,0 +1 @@
+1.1.0

exercises/variable-length-quantity/README.md

@@ -0,0 +1,50 @@
+# Variable Length Quantity
+
+Implement variable length quantity encoding and decoding.
+
+The goal of this exercise is to implement [VLQ](https://en.wikipedia.org/wiki/Variable-length_quantity) encoding/decoding.
+
+In short, the goal of this encoding is to encode integer values in a way that would save bytes.
+Only the first 7 bits of each byte is significant (right-justified; sort of like an ASCII byte).
+So, if you have a 32-bit value, you have to unpack it into a series of 7-bit bytes.
+Of course, you will have a variable number of bytes depending upon your integer.
+To indicate which is the last byte of the series, you leave bit #7 clear.
+In all of the preceding bytes, you set bit #7.
+
+So, if an integer is between `0-127`, it can be represented as one byte.
+Although VLQ can deal with numbers of arbitrary sizes, for this exercise we will restrict ourselves to only numbers that fit in a 32-bit unsigned integer.
+Here are examples of integers as 32-bit values, and the variable length quantities that they translate to:
+
+```text
+ NUMBER        VARIABLE QUANTITY
+00000000              00
+00000040              40
+0000007F              7F
+00000080             81 00
+00002000             C0 00
+00003FFF             FF 7F
+00004000           81 80 00
+00100000           C0 80 00
+001FFFFF           FF FF 7F
+00200000          81 80 80 00
+08000000          C0 80 80 00
+0FFFFFFF          FF FF FF 7F
+```
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+## Source
+
+A poor Splice developer having to implement MIDI encoding/decoding. [https://splice.com](https://splice.com)
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/variable-length-quantity/build.gradle

@@ -0,0 +1,18 @@
+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/variable-length-quantity/src/main/java/VariableLengthQuantity.java

@@ -0,0 +1,12 @@
+import java.util.List;
+
+class VariableLengthQuantity {
+
+    List<String> encode(List<Long> numbers) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    List<String> decode(List<Long> bytes) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+}

exercises/variable-length-quantity/src/test/java/VariableLengthQuantityTest.java

@@ -0,0 +1,265 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class VariableLengthQuantityTest {
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    private VariableLengthQuantity variableLengthQuantity;
+
+    @Before
+    public void setup() {
+        variableLengthQuantity = new VariableLengthQuantity();
+    }
+
+    @Test
+    public void testZero() {
+        List<String> expected = Arrays.asList("0x0");
+        List<Long> numbers = Arrays.asList(0x0L);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testArbitrarySingleByte() {
+        List<String> expected = Arrays.asList("0x40");
+        List<Long> numbers = Arrays.asList(0x40L);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLargestSingleByte() {
+        List<String> expected = Arrays.asList("0x7f");
+        List<Long> numbers = Arrays.asList(0x7fL);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSmallestDoubleByte() {
+        List<String> expected = Arrays.asList("0x81", "0x0");
+        List<Long> numbers = Arrays.asList(0x80L);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testArbitraryDoubleByte() {
+        List<String> expected = Arrays.asList("0xc0", "0x0");
+        List<Long> numbers = Arrays.asList(0x2000L);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLargestDoubleByte() {
+        List<String> expected = Arrays.asList("0xff", "0x7f");
+        List<Long> numbers = Arrays.asList(0x3fffL);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSmallestTripleByte() {
+        List<String> expected = Arrays.asList("0x81", "0x80", "0x0");
+        List<Long> numbers = Arrays.asList(0x4000L);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testArbitraryTripleByte() {
+        List<String> expected = Arrays.asList("0xc0", "0x80", "0x0");
+        List<Long> numbers = Arrays.asList(0x100000L);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLargestTripleByte() {
+       List<String> expected = Arrays.asList("0xff", "0xff", "0x7f");
+       List<Long> numbers = Arrays.asList(0x1fffffL);
+
+       assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSmallestQuadrupleByte() {
+        List<String> expected = Arrays.asList("0x81", "0x80", "0x80", "0x0");
+        List<Long> numbers = Arrays.asList(0x200000L);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testArbitraryQuadrupleByte() {
+        List<String> expected = Arrays.asList("0xc0", "0x80", "0x80", "0x0");
+        List<Long> numbers = Arrays.asList(0x8000000L);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLargestQuadrupleByte() {
+        List<String> expected = Arrays.asList("0xff", "0xff", "0xff", "0x7f");
+        List<Long> numbers = Arrays.asList(0xfffffffL);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSmallestQuintupleByte() {
+        List<String> expected = Arrays.asList("0x81", "0x80", "0x80", "0x80", "0x0");
+        List<Long> numbers = Arrays.asList(0x10000000L);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testArbitraryQuintupleByte() {
+        List<String> expected = Arrays.asList("0x8f", "0xf8", "0x80", "0x80", "0x0");
+        List<Long> numbers = Arrays.asList(0xff000000L);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testMaximum32BitIntegerInput() {
+        List<String> expected = Arrays.asList("0x8f", "0xff", "0xff", "0xff", "0x7f");
+        List<Long> numbers = Arrays.asList(0xffffffffL);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testTwoSingleByteValues() {
+        List<String> expected = Arrays.asList("0x40", "0x7f");
+        List<Long> numbers = Arrays.asList(0x40L, 0x7fL);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testTwoMultiByteValues() {
+        List<String> expected = Arrays.asList("0x81", "0x80", "0x0", "0xc8", "0xe8", "0x56");
+        List<Long> numbers = Arrays.asList(0x4000L, 0x123456L);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testManyMultiByteValues() {
+        List<String> expected = Arrays.asList("0xc0", "0x0", "0xc8", "0xe8",
+                                              "0x56", "0xff", "0xff", "0xff",
+                                              "0x7f", "0x0", "0xff", "0x7f",
+                                              "0x81", "0x80", "0x0");
+        List<Long> numbers = Arrays.asList(0x2000L, 0x123456L, 0xfffffffL,
+                                           0x0L, 0x3fffL, 0x4000L);
+
+        assertEquals(expected, variableLengthQuantity.encode(numbers));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDecodeOneByte() {
+        List<String> expected = Arrays.asList("0x7f");
+        List<Long> bytes = Arrays.asList(0x7fL);
+
+        assertEquals(expected, variableLengthQuantity.decode(bytes));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDecodeTwoBytes() {
+        List<String> expected = Arrays.asList("0x2000");
+        List<Long> bytes = Arrays.asList(0xc0L, 0x0L);
+
+        assertEquals(expected, variableLengthQuantity.decode(bytes));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDecodeThreeBytes() {
+        List<String> expected = Arrays.asList("0x1fffff");
+        List<Long> bytes = Arrays.asList(0xffL, 0xffL, 0x7fL);
+
+        assertEquals(expected, variableLengthQuantity.decode(bytes));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDecodeFourBytes() {
+        List<String> expected = Arrays.asList("0x200000");
+        List<Long> bytes = Arrays.asList(0x81L, 0x80L, 0x80L, 0x0L);
+
+        assertEquals(expected, variableLengthQuantity.decode(bytes));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDecodeMaximum32BitInteger() {
+        List<String> expected = Arrays.asList("0xffffffff");
+        List<Long> bytes = Arrays.asList(0x8fL, 0xffL, 0xffL, 0xffL, 0x7fL);
+
+        assertEquals(expected, variableLengthQuantity.decode(bytes));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testCannotDecodeIncompleteSequence() {
+        List<Long> bytes = Arrays.asList(0xffL);
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Invalid variable-length quantity encoding");
+
+        variableLengthQuantity.decode(bytes);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testCannotDecodeIncompleteSequenceEvenIfValueIsZero() {
+        List<Long> bytes = Arrays.asList(0x80L);
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Invalid variable-length quantity encoding");
+
+        variableLengthQuantity.decode(bytes);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDecodeMultipleBytes() {
+        List<String> expected = Arrays.asList("0x2000", "0x123456",
+                                              "0xfffffff", "0x0", "0x3fff",
+                                              "0x4000");
+        List<Long> bytes = Arrays.asList(0xc0L, 0x0L, 0xc8L, 0xe8L, 0x56L,
+                                         0xffL, 0xffL, 0xffL, 0x7fL, 0x0L,
+                                         0xffL, 0x7fL, 0x81L, 0x80L, 0x0L);
+
+        assertEquals(expected, variableLengthQuantity.decode(bytes));
+    }
+}