trackler 2.2.1.110 → 2.2.1.111

data/tracks/java/exercises/error-handling/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"]
+  }
+}

data/tracks/java/exercises/error-handling/src/main/java/CustomCheckedException.java

@@ -0,0 +1,11 @@
+class CustomCheckedException extends Exception {
+
+    CustomCheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    CustomCheckedException(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/java/exercises/error-handling/src/main/java/CustomUncheckedException.java

@@ -0,0 +1,11 @@
+class CustomUncheckedException extends RuntimeException {
+
+    CustomUncheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    CustomUncheckedException(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/java/exercises/error-handling/src/main/java/ErrorHandling.java

@@ -0,0 +1,49 @@
+import java.util.Optional;
+
+class ErrorHandling {
+
+    void handleErrorByThrowingIllegalArgumentException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingIllegalArgumentExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingAnyCheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingAnyCheckedExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingAnyUncheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingAnyUncheckedExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingCustomCheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingCustomCheckedExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingCustomUncheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingCustomUncheckedExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    Optional<Integer> handleErrorByReturningOptionalInstance(String integer) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/java/exercises/error-handling/src/test/java/ErrorHandlingTest.java

@@ -0,0 +1,116 @@
+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 static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Optional;
+
+public class ErrorHandlingTest {
+
+    private ErrorHandling errorHandling;
+
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
+    @Before
+    public void setUp() {
+        errorHandling = new ErrorHandling();
+    }
+
+    @Test
+    public void testThrowIllegalArgumentException() {
+        thrown.expect(IllegalArgumentException.class);
+        errorHandling.handleErrorByThrowingIllegalArgumentException();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowIllegalArgumentExceptionWithDetailMessage() {
+        thrown.expect(IllegalArgumentException.class);
+        thrown.expectMessage("This is the detail message.");
+        errorHandling.handleErrorByThrowingIllegalArgumentExceptionWithDetailMessage("This is the detail message.");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowAnyCheckedException() {
+        try {
+            errorHandling.handleErrorByThrowingAnyCheckedException();
+        } catch (Exception e) {
+            assertFalse(e instanceof RuntimeException);
+        }
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowAnyCheckedExceptionWithDetailMessage() {
+        try {
+            errorHandling.handleErrorByThrowingAnyCheckedExceptionWithDetailMessage("This is the detail message.");
+        } catch (Exception e) {
+            assertFalse(e instanceof RuntimeException);
+            assertEquals("This is the detail message.", e.getMessage());
+        }
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowAnyUncheckedException() {
+        thrown.expect(RuntimeException.class);
+        errorHandling.handleErrorByThrowingAnyUncheckedException();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowAnyUncheckedExceptionWithDetailMessage() {
+        thrown.expect(RuntimeException.class);
+        thrown.expectMessage("This is the detail message.");
+        errorHandling.handleErrorByThrowingAnyUncheckedExceptionWithDetailMessage("This is the detail message.");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowCustomCheckedException() throws CustomCheckedException {
+        thrown.expect(CustomCheckedException.class);
+        errorHandling.handleErrorByThrowingCustomCheckedException();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowCustomCheckedExceptionWithDetailMessage() throws CustomCheckedException {
+        thrown.expect(CustomCheckedException.class);
+        thrown.expectMessage("This is the detail message.");
+        errorHandling.handleErrorByThrowingCustomCheckedExceptionWithDetailMessage("This is the detail message.");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowCustomUncheckedException() {
+        thrown.expect(CustomUncheckedException.class);
+        errorHandling.handleErrorByThrowingCustomUncheckedException();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowCustomUncheckedExceptionWithDetailMessage() {
+        thrown.expect(CustomUncheckedException.class);
+        thrown.expectMessage("This is the detail message.");
+        errorHandling.handleErrorByThrowingCustomUncheckedExceptionWithDetailMessage("This is the detail message.");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testReturnOptionalInstance() {
+        Optional<Integer> successfulResult = errorHandling.handleErrorByReturningOptionalInstance("1");
+        assertTrue(successfulResult.isPresent());
+        assertEquals(1, (int) successfulResult.get());
+
+        Optional<Integer> failureResult = errorHandling.handleErrorByReturningOptionalInstance("a");
+        assertFalse(failureResult.isPresent());
+    }
+
+}

data/tracks/java/exercises/flatten-array/.meta/version

@@ -1 +1 @@
-1.1.0
+1.2.0

data/tracks/java/exercises/nth-prime/.meta/version

@@ -1 +1 @@
-2.0.0
+2.1.0

data/tracks/java/exercises/pig-latin/README.md

@@ -7,10 +7,10 @@ confusing. It obeys a few simple rules (below), but when it's spoken
 quickly it's really difficult for non-children (and non-native speakers)
 to understand.
 
-- **Rule 1**: If a word begins with a vowel sound, add an "ay" sound to
-  the end of the word.
-- **Rule 2**: If a word begins with a consonant sound, move it to the
-  end of the word, and then add an "ay" sound to the end of the word.
+- **Rule 1**: If a word begins with a vowel sound, add an "ay" sound to the end of the word. Please note that "xr" and "yt" at the beginning of a word make vowel sounds (e.g. "xray" -> "xrayay", "yttria" -> "yttriaay").
+- **Rule 2**: If a word begins with a consonant sound, move it to the end of the word and then add an "ay" sound to the end of the word. Consonant sounds can be made up of multiple consonants, a.k.a. a consonant cluster (e.g. "chair" -> "airchay").
+- **Rule 3**: If a word starts with a consonant sound followed by "qu", move it to the end of the word, and then add an "ay" sound to the end of the word (e.g. "square" -> "aresquay").
+- **Rule 4**: If a word contains a "y" after a consonant cluster or as the second letter in a two letter word it makes a vowel sound (e.g. "rhythm" -> "ythmrhay", "my" -> "ymay").
 
 There are a few more rules for edge cases, and there are regional
 variants too.

data/tracks/java/exercises/protein-translation/.meta/version

@@ -1 +1 @@
-1.0.1
+1.1.0

data/tracks/java/exercises/saddle-points/.meta/version

@@ -1 +1 @@
-1.0.0
+1.1.0

data/tracks/java/exercises/settings.gradle

@@ -24,6 +24,8 @@ include 'crypto-square'
 include 'custom-set'
 include 'diamond'
 include 'difference-of-squares'
+include 'diffie-hellman'
+include 'error-handling'
 include 'etl'
 include 'flatten-array'
 include 'food-chain'
@@ -92,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'

data/tracks/java/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;
+    }
+}

data/tracks/java/exercises/variable-length-quantity/.meta/version

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

data/tracks/java/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.

data/tracks/java/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"]
+    }
+}

data/tracks/java/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.");
+    }
+}

data/tracks/java/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));
+    }
+}