trackler 2.2.1.110 → 2.2.1.111

data/tracks/haskell/exercises/zipper/README.md

@@ -80,6 +80,5 @@ GitHub is the home for all of the Haskell exercises.
 If you have feedback about an exercise, or want to help implementing a new
 one, head over there and create an issue.  We'll do our best to help you!
 
-
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/java/config.json

@@ -395,6 +395,17 @@
       "unlocked_by": null,
       "uuid": "8dfc2f0d-1141-46e9-95e2-6f35ccf6f160"
     },
+    {
+      "core": false,
+      "difficulty": 4,
+      "slug": "error-handling",
+      "topics": [
+        "exception_handling",
+        "optional_values"
+      ],
+      "unlocked_by": "triangle",
+      "uuid": "846ae792-7ca7-43e1-b523-bb1ec9fa08eb"
+    },
     {
       "core": false,
       "difficulty": 4,
@@ -422,6 +433,21 @@
       "unlocked_by": "hello-world",
       "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,
@@ -1116,6 +1142,18 @@
       "unlocked_by": "flatten-array",
       "uuid": "e5f05d00-fe5b-4d78-b2fa-934c1c9afb32"
     },
+    {
+      "core": false,
+      "difficulty": 8,
+      "slug": "diffie-hellman",
+      "topics": [
+        "algorithms",
+        "integers",
+        "transforming"
+      ],
+      "unlocked_by": "linked-list",
+      "uuid": "9b191b2f-b1a4-4c0e-b911-36666bff614d"
+    },
     {
       "core": false,
       "difficulty": 8,

data/tracks/java/exercises/atbash-cipher/.meta/version

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

data/tracks/java/exercises/collatz-conjecture/.meta/version

@@ -1 +1 @@
-1.1.1
+1.2.0

data/tracks/java/exercises/diffie-hellman/.meta/hints.md

@@ -0,0 +1,3 @@
+## Hints
+This exercise requires you to perform calculations on large numbers. To correctly represent large numbers, the
+[BigInteger](https://docs.oracle.com/javase/8/docs/api/java/math/BigInteger.html) class is used.

data/tracks/java/exercises/diffie-hellman/.meta/src/reference/java/DiffieHellman.java

@@ -0,0 +1,24 @@
+import java.math.BigInteger;
+import java.util.Random;
+
+class DiffieHellman {
+
+    private Random random = new Random();
+
+    BigInteger privateKey(BigInteger primeP) {
+        BigInteger privateKey;
+        do {
+            privateKey = new BigInteger(primeP.bitLength(), random);
+        } while (privateKey.compareTo(BigInteger.ZERO) == 0 || privateKey.compareTo(primeP) >= 0);
+        return privateKey;
+    }
+
+    BigInteger publicKey(BigInteger primeP, BigInteger primeG, BigInteger privateKey) {
+        return primeG.modPow(privateKey, primeP);
+    }
+
+    BigInteger secret(BigInteger primeP, BigInteger publicKey, BigInteger privateKey) {
+        return publicKey.modPow(privateKey, primeP);
+    }
+
+}

data/tracks/java/exercises/diffie-hellman/README.md

@@ -0,0 +1,63 @@
+# Diffie Hellman
+
+Diffie-Hellman key exchange.
+
+Alice and Bob use Diffie-Hellman key exchange to share secrets.  They
+start with prime numbers, pick private keys, generate and share public
+keys, and then generate a shared secret key.
+
+## Step 0
+
+The test program supplies prime numbers p and g.
+
+## Step 1
+
+Alice picks a private key, a, greater than 1 and less than p.  Bob does
+the same to pick a private key b.
+
+## Step 2
+
+Alice calculates a public key A.
+
+    A = g**a mod p
+
+Using the same p and g, Bob similarly calculates a public key B from his
+private key b.
+
+## Step 3
+
+Alice and Bob exchange public keys.  Alice calculates secret key s.
+
+    s = B**a mod p
+
+Bob calculates
+
+    s = A**b mod p
+
+The calculations produce the same result!  Alice and Bob now share
+secret s.
+
+# Java Tips
+
+## Hints
+This exercise requires you to perform calculations on large numbers. To correctly represent large numbers, the
+[BigInteger](https://docs.oracle.com/javase/8/docs/api/java/math/BigInteger.html) class is used.
+
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+## Source
+
+Wikipedia, 1024 bit key from www.cryptopp.com/wiki. [http://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange](http://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange)
+
+## 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/diffie-hellman/build.gradle

@@ -0,0 +1,19 @@
+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/diffie-hellman/src/test/java/DiffieHellmanTest.java

@@ -0,0 +1,98 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
+
+import java.math.BigInteger;
+import java.util.*;
+
+public class DiffieHellmanTest {
+
+    private DiffieHellman diffieHellman;
+
+    @Before
+    public void setUp() {
+        diffieHellman = new DiffieHellman();
+    }
+
+    @Test
+    public void testPrivateKeyInRange() {
+        BigInteger prime = BigInteger.valueOf(23);
+        List<BigInteger> privateKeys = new ArrayList<>();
+        for (int i = 0; i < 10; i++) {
+            privateKeys.add(diffieHellman.privateKey(prime));
+        }
+
+        for (BigInteger privateKey : privateKeys) {
+            assertTrue(privateKey.compareTo(BigInteger.ONE) >= 0);
+            assertTrue(privateKey.compareTo(prime) < 0);
+        }
+    }
+
+    // Note: due to the nature of randomness, there is always a chance that this test fails
+    // Be sure to check the actual generated values
+    @Ignore("Remove to run test")
+    @Test
+    public void testPrivateKeyRandomlyGenerated() {
+        BigInteger prime = BigInteger.valueOf(7919);
+        BigInteger privateKeyA = diffieHellman.privateKey(prime);
+        BigInteger privateKeyB = diffieHellman.privateKey(prime);
+
+        assertNotEquals(privateKeyA, privateKeyB);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testPublicKeyCorrectlyCalculated() {
+        BigInteger primeA = BigInteger.valueOf(23);
+        BigInteger primeB = BigInteger.valueOf(5);
+        BigInteger privateKey = BigInteger.valueOf(6);
+        BigInteger expected = BigInteger.valueOf(8);
+
+        assertEquals(expected, diffieHellman.publicKey(primeA, primeB, privateKey));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSecretKeyCorrectlyCalculated() {
+        BigInteger prime = BigInteger.valueOf(23);
+        BigInteger publicKey = BigInteger.valueOf(19);
+        BigInteger privateKey = BigInteger.valueOf(6);
+        BigInteger expected = BigInteger.valueOf(2);
+
+        assertEquals(expected, diffieHellman.secret(prime, publicKey, privateKey));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSecretKeyCorrectlyCalculatedWhenUsingLargePrimes() {
+        BigInteger prime = new BigInteger("120227323036150778550155526710966921740030662694578947298423549235265759593711587341037426347114541533006628856300552706996143592240453345642869233562886752930249953227657883929905072620233073626594386072962776144691433658814261874113232461749035425712805067202910389407991986070558964461330091797026762932543");
+        BigInteger publicKey = new BigInteger("75205441154357919442925546169208711235485855904969178206313309299205868312399046149367516336607966149689640419216591714331722664409474612463910928128055994157922930443733535659848264364106037925315974095321112757711756912144137705613776063541350548911512715512539186192176020596861210448363099541947258202188");
+        BigInteger privateKey = new BigInteger("2483479393625932939911081304356888505153797135447327501792696199190469015215177630758617902200417377685436170904594686456961202706692908603181062371925882");
+        BigInteger expected = new BigInteger("70900735223964890815905879227737819348808518698920446491346508980461201746567735331455825644429877946556431095820785835497384849778344216981228226252639932672153547963980483673419756271345828771971984887453014488572245819864454136618980914729839523581263886740821363010486083940557620831348661126601106717071");
+
+        assertEquals(expected, diffieHellman.secret(prime, publicKey, privateKey));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testExchange() {
+        BigInteger primeA = BigInteger.valueOf(23);
+        BigInteger primeB = BigInteger.valueOf(5);
+
+        BigInteger privateKeyA = diffieHellman.privateKey(primeA);
+        BigInteger privateKeyB = diffieHellman.privateKey(primeB);
+
+        BigInteger publicKeyA = diffieHellman.publicKey(primeA, primeB, privateKeyA);
+        BigInteger publicKeyB = diffieHellman.publicKey(primeA, primeB, privateKeyB);
+
+        BigInteger secretA = diffieHellman.secret(primeA, publicKeyB, privateKeyA);
+        BigInteger secretB = diffieHellman.secret(primeA, publicKeyA, privateKeyB);
+
+        assertEquals(secretA, secretB);
+    }
+
+}

data/tracks/java/exercises/error-handling/.meta/hints.md

@@ -0,0 +1,35 @@
+This exercise requires you to handle exceptions. An [exception](https://docs.oracle.com/javase/tutorial/essential/exceptions/definition.html) is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions.
+
+In Java, there are two types of exceptions: checked and unchecked exceptions.
+
+- [Checked vs Unchecked Exceptions in Java](https://www.geeksforgeeks.org/checked-vs-unchecked-exceptions-in-java/)
+
+- [Unchecked Exceptions — The Controversy](https://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html)
+
+## Checked exceptions
+
+Checked exceptions are the exceptions that are checked at [compile time](https://en.wikipedia.org/wiki/Compile_time).
+
+### Practical implications
+
+You have to declare them in the [method signature](https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html) of any method that can [throw](https://docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html) a checked exception and handle or rethrow them when calling any method that can throw a checked exception.
+
+This is because checked exceptions are meant to be handled at runtime, i.e. they are errors you can recover from.
+
+### Examples of where they are used
+
+They're often used when a method can't return any valid result, for example a search method which hasn't found the item it was searching for.
+
+It's an alternative to returning null or a error code. A checked exception is better than those alternatives because it forces the user of the method to consider the error case.
+
+## Unchecked exceptions
+
+Unchecked exceptions are the exceptions that are not checked at [compile time](https://en.wikipedia.org/wiki/Compile_time).
+
+### Practical implications
+
+You don't have to declare them in the [method signature](https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html) of methods that can [throw](https://docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html) an unchecked exception and handle or rethrow them when calling any method that can throw an unchecked exception.
+
+### Examples of where they are used
+
+Unchecked exceptions are mean to be used for any error than can't be handled at runtime, e.g. running out of memory.

data/tracks/java/exercises/error-handling/.meta/src/reference/java/CustomCheckedException.java

@@ -0,0 +1,11 @@
+class CustomCheckedException extends Exception {
+
+    CustomCheckedException() {
+        super();
+    }
+
+    CustomCheckedException(String message) {
+        super(message);
+    }
+
+}

data/tracks/java/exercises/error-handling/.meta/src/reference/java/CustomUncheckedException.java

@@ -0,0 +1,11 @@
+class CustomUncheckedException extends RuntimeException {
+
+    CustomUncheckedException() {
+        super();
+    }
+
+    CustomUncheckedException(String message) {
+        super(message);
+    }
+
+}

data/tracks/java/exercises/error-handling/.meta/src/reference/java/ErrorHandling.java

@@ -0,0 +1,63 @@
+import java.io.IOException;
+import java.util.Optional;
+
+class ErrorHandling {
+
+    void handleErrorByThrowingIllegalArgumentException() {
+        throw new IllegalArgumentException();
+    }
+
+    void handleErrorByThrowingIllegalArgumentExceptionWithDetailMessage(String message) {
+        throw new IllegalArgumentException(message);
+    }
+
+    void handleErrorByThrowingAnyCheckedException() throws IOException {
+        throw new IOException();
+    }
+
+    void handleErrorByThrowingAnyCheckedExceptionWithDetailMessage(String message) throws IOException {
+        throw new IOException(message);
+    }
+
+    void handleErrorByThrowingAnyUncheckedException() {
+        throw new NullPointerException();
+    }
+
+    void handleErrorByThrowingAnyUncheckedExceptionWithDetailMessage(String message) {
+        throw new NullPointerException(message);
+    }
+
+    void handleErrorByThrowingCustomCheckedException() throws CustomCheckedException {
+        throw new CustomCheckedException();
+    }
+
+    void handleErrorByThrowingCustomCheckedExceptionWithDetailMessage(String message) throws CustomCheckedException {
+        throw new CustomCheckedException(message);
+    }
+
+    void handleErrorByThrowingCustomUncheckedException() {
+        throw new CustomUncheckedException();
+    }
+
+    void handleErrorByThrowingCustomUncheckedExceptionWithDetailMessage(String message) {
+        throw new CustomUncheckedException(message);
+    }
+
+    Optional<Integer> handleErrorByReturningOptionalInstance(String integer) {
+        if (tryParseInt(integer)) {
+            return Optional.of(Integer.parseInt(integer));
+        } else {
+            return Optional.empty();
+        }
+    }
+
+    private boolean tryParseInt(String integer) {
+        try {
+            Integer.parseInt(integer);
+            return true;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+
+}

data/tracks/java/exercises/error-handling/README.md

@@ -0,0 +1,24 @@
+# Error Handling
+
+Implement various kinds of error handling and resource management.
+
+An important point of programming is how to handle errors and close
+resources even if errors occur.
+
+This exercise requires you to handle various errors. Because error handling
+is rather programming language specific you'll have to refer to the tests
+for your track to see what's exactly required.
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.