trackler 2.2.1.75 → 2.2.1.76

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

@@ -2,8 +2,6 @@
 
 Reparent a graph on a selected node.
 
-# Tree Reparenting
-
 This exercise is all about re-orientating a graph to see things from a different
 point of view. For example family trees are usually presented from the
 ancestor's perspective:

data/tracks/haskell/exercises/secret-handshake/README.md

@@ -83,7 +83,7 @@ one, head over there and create an issue.  We'll do our best to help you!
 
 ## Source
 
-Bert, in Mary Poppins [http://www.imdb.com/character/ch0011238/quotes](http://www.imdb.com/character/ch0011238/quotes)
+Bert, in Mary Poppins [http://www.imdb.com/title/tt0058331/quotes/qt0437047](http://www.imdb.com/title/tt0058331/quotes/qt0437047)
 
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/haskell/exercises/simple-cipher/README.md

@@ -58,15 +58,13 @@ would get the same thing as the Caesar Cipher.
 
 The weakest link in any cipher is the human being. Let's make your
 substitution cipher a little more fault tolerant by providing a source
-of randomness and ensuring that the key is not composed of numbers or
-capital letters.
+of randomness and ensuring that the key contains only lowercase letters.
 
 If someone doesn't submit a key at all, generate a truly random key of
-at least 100 characters in length, accessible via Cipher#key (the #
-syntax means instance variable)
+at least 100 characters in length.
 
-If the key submitted has capital letters or numbers, throw an
-ArgumentError with a message to that effect.
+If the key submitted is not composed only of lowercase letters, your
+solution should handle the error in a language-appropriate way.
 
 ## Extensions
 

data/tracks/java/config.json

@@ -23,6 +23,18 @@
       "unlocked_by": null,
       "uuid": "74515d45-565b-4be2-96c4-77e58efa9257"
     },
+    {
+      "core": false,
+      "difficulty": 6,
+      "slug": "parallel-letter-frequency",
+      "topics": [
+        "concurrency",
+        "maps",
+        "strings"
+      ],
+      "unlocked_by": "hamming",
+      "uuid": "38a405e8-619d-400f-b53c-2f06461fdf9d"
+    },
     {
       "core": false,
       "difficulty": 1,

data/tracks/java/exercises/beer-song/README.md

@@ -1,6 +1,6 @@
 # Beer Song
 
-Produce the lyrics to that beloved classic, that field-trip favorite: 99 Bottles of Beer on the Wall.
+Recite the lyrics to that beloved classic, that field-trip favorite: 99 Bottles of Beer on the Wall.
 
 Note that not all verses are identical.
 

data/tracks/java/exercises/house/README.md

@@ -1,6 +1,6 @@
 # House
 
-Output the nursery rhyme 'This is the House that Jack Built'.
+Recite the nursery rhyme 'This is the House that Jack Built'.
 
 > [The] process of placing a phrase of clause within another phrase of
 > clause is called embedding. It is through the processes of recursion

data/tracks/java/exercises/isbn-verifier/README.md

@@ -1,39 +1,45 @@
-Check if a given ISBN-10 is valid.
+# Isbn Verifier
 
-## Functionality
+The [ISBN-10 verification process](https://en.wikipedia.org/wiki/International_Standard_Book_Number) is used to validate book identification
+numbers. These normally contain dashes and look like: `3-598-21508-8`
 
-Given an unknown string the program should check if the provided string is a valid ISBN-10.
-Putting this into place requires some thinking about preprocessing/parsing of the string prior to calculating the check digit for the ISBN.
+## ISBN
 
-The program should allow for ISBN-10 without the separating dashes to be verified as well.
+The ISBN-10 format is 9 digits (0 to 9) plus one check character (either a digit or an X only). In the case the check character is an X, this represents the value '10'. These may be communicated with or without hyphens, and can be checked for their validity by the following formula:
 
-## ISBN
+```
+(x1 * 10 + x2 * 9 + x3 * 8 + x4 * 7 + x5 * 6 + x6 * 5 + x7 * 4 + x8 * 3 + x9 * 2 + x10 * 1) mod 11 == 0
+```
 
-Let's take a random ISBN-10 number, say `3-598-21508-8` for this.
-The first digit block indicates the group where the ISBN belongs. Groups can consist of shared languages, geographic regions or countries. The leading '3' signals this ISBN is from a german speaking country.
-The following number block is to identify the publisher. Since this is a three digit publisher number there is a 5 digit title number for this book.
-The last digit in the ISBN is the check digit which is used to detect read errors.
+If the result is 0, then it is a valid ISBN-10, otherwise it is invalid.
 
-The first 9 digits in the ISBN have to be between 0 and 9.
-The check digit can additionally be an 'X' to allow 10 to be a valid check digit as well.
+## Example
 
-A valid ISBN-10 is calculated with this formula `(x1 * 10 + x2 * 9 + x3 * 8 + x4 * 7 + x5 * 6 + x6 * 5 + x7 * 4 + x8 * 3 + x9 * 2 + x10 * 1) mod 11 == 0`
-So for our example ISBN this means:
-(3 * 10 + 5 * 9 + 9 * 8 + 8 * 7 + 2 * 6 + 1 * 5 + 5 * 4 + 0 * 3 + 8 * 2 + 8 * 1) mod 11 = 0
+Let's take the ISBN-10 `3-598-21508-8`. We plug it in to the formula, and get:
+```
+(3 * 10 + 5 * 9 + 9 * 8 + 8 * 7 + 2 * 6 + 1 * 5 + 5 * 4 + 0 * 3 + 8 * 2 + 8 * 1) mod 11 == 0
+```
+
+Since the result is 0, this proves that our ISBN is valid.
+
+## Task
+
+Given a string the program should check if the provided string is a valid ISBN-10.
+Putting this into place requires some thinking about preprocessing/parsing of the string prior to calculating the check digit for the ISBN.
+
+The program should be able to verify ISBN-10 both with and without separating dashes.
 
-Which proves that the ISBN is valid.
 
 ## Caveats
 
-Converting from string to number can be tricky in certain languages.
-It's getting even trickier since the check-digit of an ISBN-10 can be 'X'.
+Converting from strings to numbers can be tricky in certain languages.
+Now, it's even trickier since the check digit of an ISBN-10 may be 'X' (representing '10'). For instance `3-598-21507-X` is a valid ISBN-10.
 
 ## Bonus tasks
 
-* Generate a valid ISBN-13 from the input ISBN-10 (and maybe verify it again with a derived verifier)
-
-* Generate valid ISBN, maybe even from a given starting ISBN
+* Generate a valid ISBN-13 from the input ISBN-10 (and maybe verify it again with a derived verifier).
 
+* Generate valid ISBN, maybe even from a given starting ISBN.
 # Running the tests
 
 You can run all the tests for an exercise by entering

data/tracks/java/exercises/kindergarten-garden/README.md

@@ -9,8 +9,8 @@ actual dirt, and grow actual plants.
 
 They've chosen to grow grass, clover, radishes, and violets.
 
-To this end, the children have put little cups along the window sills, and 
-planted one type of plant in each cup, choosing randomly from the available 
+To this end, the children have put little cups along the window sills, and
+planted one type of plant in each cup, choosing randomly from the available
 types of seeds.
 
 ```text
@@ -25,7 +25,7 @@ There are 12 children in the class:
 - Eve, Fred, Ginny, Harriet,
 - Ileana, Joseph, Kincaid, and Larry.
 
-Each child gets 4 cups, two on each row. Their teacher assigns cups to 
+Each child gets 4 cups, two on each row. Their teacher assigns cups to
 the children alphabetically by their names.
 
 The following diagram represents Alice's plants:

data/tracks/java/exercises/meetup/README.md

@@ -2,25 +2,29 @@
 
 Calculate the date of meetups.
 
-Typically meetups happen on the same day of the week.  In this exercise, you will take
-a description of a meetup date, and return the actual meetup date.
+Typically meetups happen on the same day of the week.  In this exercise, you
+will take a description of a meetup date, and return the actual meetup date.
 
 Examples of general descriptions are:
 
-- the first Monday of January 2017
-- the third Tuesday of January 2017
-- the Wednesteenth of January 2017
-- the last Thursday of January 2017
+- The first Monday of January 2017
+- The third Tuesday of January 2017
+- The wednesteenth of January 2017
+- The last Thursday of January 2017
 
-Note that "Monteenth", "Tuesteenth", etc are all made up words. There
-was a meetup whose members realized that there are exactly 7 numbered days in a month that
-end in '-teenth'. Therefore, one is guaranteed that each day of the week
+The descriptors you are expected to parse are:
+first, second, third, fourth, fifth, last, monteenth, tuesteenth, wednesteenth,
+thursteenth, friteenth, saturteenth, sunteenth
+
+Note that "monteenth", "tuesteenth", etc are all made up words. There was a
+meetup whose members realized that there are exactly 7 numbered days in a month
+that end in '-teenth'. Therefore, one is guaranteed that each day of the week
 (Monday, Tuesday, ...) will have exactly one date that is named with '-teenth'
 in every month.
 
-Given examples of a meetup dates, each containing a month, day, year, and descriptor
-(first, second, teenth, etc), calculate the date of the actual meetup.
-For example, if given "First Monday of January 2017", the correct meetup date is 2017/1/2
+Given examples of a meetup dates, each containing a month, day, year, and
+descriptor calculate the date of the actual meetup.  For example, if given
+"The first Monday of January 2017", the correct meetup date is 2017/1/2.
 
 # Running the tests
 

data/tracks/java/exercises/nucleotide-count/README.md

@@ -2,8 +2,8 @@
 
 Given a single stranded DNA string, compute how many times each nucleotide occurs in the string.
 
-The genetic language of every living thing on the planet is DNA. 
-DNA is a large molecule that is built from an extremely long sequence of individual elements called nucleotides. 
+The genetic language of every living thing on the planet is DNA.
+DNA is a large molecule that is built from an extremely long sequence of individual elements called nucleotides.
 4 types exist in DNA and these differ only slightly and can be represented as the following symbols: 'A' for adenine, 'C' for cytosine, 'G' for guanine, and 'T' thymine.
 
 Here is an analogy:

data/tracks/java/exercises/palindrome-products/README.md

@@ -9,7 +9,7 @@ Given a range of numbers, find the largest and smallest palindromes which
 are products of numbers within that range.
 
 Your solution should return the largest and smallest palindromes, along with the
-factors of each within the range. If the largest or smallest palindrome has more 
+factors of each within the range. If the largest or smallest palindrome has more
 than one pair of factors within the range, then return all the pairs.
 
 ## Example 1

data/tracks/java/exercises/parallel-letter-frequency/.meta/HINTS.md

@@ -0,0 +1,3 @@
+Single-threaded (non-concurrent) solutions can pass all tests [but the last.](https://www.youtube.com/watch?v=mJZZNHekEQw)  Your solution will be tested for concurrency by submitting it as a [Runnable](https://docs.oracle.com/javase/7/docs/api/java/lang/Runnable.html) to an [ExecutorService.](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ExecutorService.html) Your solution must leverage multiple [Threads](https://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html) to pass the final test.
+
+Java documentation on [parallel streams](https://docs.oracle.com/javase/tutorial/collections/streams/parallelism.html) may provide some help.

data/tracks/java/exercises/parallel-letter-frequency/.meta/src/reference/java/ParallelLetterFrequency.java

@@ -0,0 +1,45 @@
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+
+class ParallelLetterFrequency {
+
+    private static Map<Integer, Integer> letterFrequencyMap;
+    private final String NOT_A_LETTER = "\\P{L}+";
+
+
+    ParallelLetterFrequency(String letters) {
+        letterFrequencyMap = getMapFromLetters(letters.toLowerCase().replaceAll(NOT_A_LETTER, ""));
+    }
+
+    Map<Integer, Integer> getMapFromLetters(String letters) {
+        return letters
+                .chars()
+                .parallel()
+                .collect(Counts::new, Counts::increment, Counts::combine)
+                .buildMap();
+    }
+
+    private static class Counts {
+
+        private Map<Integer, Integer> letterCounts = new HashMap<>();
+
+        private void increment(int letter) {
+            letterCounts.put(letter, letterCounts.getOrDefault(letter, 0) + 1);
+        }
+
+        private void combine(Counts other) {
+            other.letterCounts.keySet()
+                    .forEach(letter -> letterCounts.merge(letter, other.letterCounts.get(letter), Integer::sum));
+        }
+
+        private Map<Integer, Integer> buildMap() {
+            return Collections.unmodifiableMap(letterCounts);
+        }
+    }
+
+    Map<Integer, Integer> letterCounts() {
+        return letterFrequencyMap;
+    }
+}

data/tracks/java/exercises/parallel-letter-frequency/README.md

@@ -0,0 +1,30 @@
+# Parallel Letter Frequency
+
+Count the frequency of letters in texts using parallel computation.
+
+Parallelism is about doing things in parallel that can also be done
+sequentially. A common example is counting the frequency of letters.
+Create a function that returns the total frequency of each letter in a
+list of texts and that employs parallelism.
+
+# Java Tips
+
+Single-threaded (non-concurrent) solutions can pass all tests [but the last.](https://www.youtube.com/watch?v=mJZZNHekEQw)  Your solution will be tested for concurrency by submitting it as a [Runnable](https://docs.oracle.com/javase/7/docs/api/java/lang/Runnable.html) to an [ExecutorService.](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ExecutorService.html) Your solution must leverage multiple [Threads](https://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html) to pass the final test.
+
+Java documentation on [parallel streams](https://docs.oracle.com/javase/tutorial/collections/streams/parallelism.html) may provide some help.
+
+
+# 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.

data/tracks/java/exercises/parallel-letter-frequency/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/parallel-letter-frequency/src/test/java/ParallelLetterFrequencyTest.java

@@ -0,0 +1,235 @@
+import org.junit.*;
+
+import static org.junit.Assert.*;
+
+import java.util.concurrent.*;
+import java.util.stream.*;
+import java.util.*;
+
+public class ParallelLetterFrequencyTest {
+
+    // Poem by Friedrich Schiller. The corresponding music is the European Anthem.
+    private String OdeAnDieFreude =
+            "Freude schöner Götterfunken\n" +
+                    "Tochter aus Elysium,\n" +
+                    "Wir betreten feuertrunken,\n" +
+                    "Himmlische, dein Heiligtum!\n" +
+                    "Deine Zauber binden wieder\n" +
+                    "Was die Mode streng geteilt;\n" +
+                    "Alle Menschen werden Brüder,\n" +
+                    "Wo dein sanfter Flügel weilt.";
+
+    // Dutch national anthem
+    private String Wilhelmus =
+            "Wilhelmus van Nassouwe\n" +
+                    "ben ik, van Duitsen bloed,\n" +
+                    "den vaderland getrouwe\n" +
+                    "blijf ik tot in den dood.\n" +
+                    "Een Prinse van Oranje\n" +
+                    "ben ik, vrij, onverveerd,\n" +
+                    "den Koning van Hispanje\n" +
+                    "heb ik altijd geëerd.";
+
+    // American national anthem
+    private String StarSpangledBanner =
+            "O say can you see by the dawn's early light,\n" +
+                    "What so proudly we hailed at the twilight's last gleaming,\n" +
+                    "Whose broad stripes and bright stars through the perilous fight,\n" +
+                    "O'er the ramparts we watched, were so gallantly streaming?\n" +
+                    "And the rockets' red glare, the bombs bursting in air,\n" +
+                    "Gave proof through the night that our flag was still there;\n" +
+                    "O say does that star-spangled banner yet wave,\n" +
+                    "O'er the land of the free and the home of the brave?\n";
+
+
+    @Test
+    public void noTextsMeansNoLetters() {
+        String input = "";
+        Map<Integer, Integer> expectedOutput = new HashMap<Integer, Integer>();
+        ParallelLetterFrequency p = new ParallelLetterFrequency(input);
+
+        assertEquals(expectedOutput, p.letterCounts());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneLetterIsCorrectlyCounted() {
+        String input = "a";
+        Map<Integer, Integer> expectedOutput = new HashMap<Integer, Integer>() {
+            {
+                put((int) 'a', 1);
+            }
+        };
+        ParallelLetterFrequency p = new ParallelLetterFrequency(input);
+
+        assertEquals(expectedOutput, p.letterCounts());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void resultsAreCaseInsensitive() {
+        String input = "Aa";
+        Map<Integer, Integer> expectedOutput = new HashMap<Integer, Integer>() {
+            {
+                put((int) 'a', 2);
+            }
+        };
+        ParallelLetterFrequency p = new ParallelLetterFrequency(input);
+
+        assertEquals(expectedOutput, p.letterCounts());
+    }
+
+
+    @Ignore("Remove to run test")
+    @Test
+    public void biggerEmptyTextsStillReturnNoResults() {
+        StringBuilder b = new StringBuilder();
+        for (int i = 0; i < 10000; i++) {
+            b.append(" ");
+        }
+
+        Map<Integer, Integer> expectedOutput = new HashMap<Integer, Integer>();
+        ParallelLetterFrequency p = new ParallelLetterFrequency(b.toString());
+
+        assertEquals(expectedOutput, p.letterCounts());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void manyRepetitionsOfTheSameTextGiveAPredictableResult() {
+        StringBuilder b = new StringBuilder();
+        for (int i = 0; i < 10000; i++) {
+            b.append("abc");
+        }
+
+        Map<Integer, Integer> expectedOutput = new HashMap<Integer, Integer>() {
+            {
+                put((int) 'a', 10000);
+                put((int) 'b', 10000);
+                put((int) 'c', 10000);
+            }
+        };
+        ParallelLetterFrequency p = new ParallelLetterFrequency(b.toString());
+
+        assertEquals(expectedOutput, p.letterCounts());
+    }
+
+
+    @Ignore("Remove to run test")
+    @Test
+    public void punctuationDoesntCount() {
+        ParallelLetterFrequency p = new ParallelLetterFrequency(OdeAnDieFreude);
+
+        assertFalse(p.letterCounts().containsKey((int) ','));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void numbersDontCount() {
+        ParallelLetterFrequency p = new ParallelLetterFrequency("Testing, 1, 2, 3");
+
+        assertFalse(p.letterCounts().containsKey((int) '1'));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void allThreeAnthemsTogetherProduceCorrectCounts() {
+        StringBuilder b = new StringBuilder();
+        b.append(OdeAnDieFreude);
+        b.append(Wilhelmus);
+        b.append(StarSpangledBanner);
+
+        ParallelLetterFrequency p = new ParallelLetterFrequency(b.toString());
+
+        assertEquals(new Integer(49), p.letterCounts().get((int) 'a'));
+        assertEquals(new Integer(56), p.letterCounts().get((int) 't'));
+        assertEquals(new Integer(2), p.letterCounts().get((int) 'ü'));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleThreadsGetUsed()
+            throws InterruptedException, ExecutionException {
+
+
+        class MyForkJoinWorkerThread extends ForkJoinWorkerThread {
+
+            boolean wasStarted = false;
+
+            public MyForkJoinWorkerThread(ForkJoinPool pool) {
+                super(pool);
+            }
+
+            @Override
+            public void start() {
+                super.start();
+                this.wasStarted = true;
+            }
+        }
+
+        List<MyForkJoinWorkerThread> allThreads = new ArrayList<>();
+
+        class MyForkJoinThreadFactory implements ForkJoinPool.ForkJoinWorkerThreadFactory {
+            public MyForkJoinThreadFactory() {
+                super();
+            }
+
+            public MyForkJoinWorkerThread newThread(ForkJoinPool pool) {
+                final MyForkJoinWorkerThread worker = new MyForkJoinWorkerThread(pool);
+                worker.setName("Thread number: " + worker.getPoolIndex());
+                allThreads.add(worker);
+                return worker;
+            }
+        }
+
+        MyForkJoinThreadFactory factory = new MyForkJoinThreadFactory();
+        ForkJoinPool multiThreadPool = new ForkJoinPool(4, (ForkJoinPool.ForkJoinWorkerThreadFactory) factory, null, false);
+
+        String input = "abcdefghijklmnopqrstuvwxyz";
+        StringBuilder b = new StringBuilder();
+        for (int i = 1; i < 10000000; i++) {
+            b.append(input);
+        }
+
+        Map<Integer, Integer> expectedOutput = new HashMap<Integer, Integer>() {
+            {
+                put((int) 'a', 10000000);
+                put((int) 'b', 10000000);
+                put((int) 'c', 10000000);
+                put((int) 'd', 10000000);
+                put((int) 'e', 10000000);
+                put((int) 'f', 10000000);
+                put((int) 'g', 10000000);
+                put((int) 'h', 10000000);
+                put((int) 'i', 10000000);
+                put((int) 'j', 10000000);
+                put((int) 'k', 10000000);
+                put((int) 'l', 10000000);
+                put((int) 'm', 10000000);
+                put((int) 'n', 10000000);
+                put((int) 'o', 10000000);
+                put((int) 'p', 10000000);
+                put((int) 'q', 10000000);
+                put((int) 'r', 10000000);
+                put((int) 's', 10000000);
+                put((int) 't', 10000000);
+                put((int) 'u', 10000000);
+                put((int) 'v', 10000000);
+                put((int) 'w', 10000000);
+                put((int) 'x', 10000000);
+                put((int) 'y', 10000000);
+                put((int) 'z', 10000000);
+            }
+        };
+
+        Map<Integer, Integer> multiCounts = multiThreadPool.submit(
+                () -> (new ParallelLetterFrequency(b.toString()).letterCounts())
+        ).get();
+
+        boolean startedThreadCountEqualsPoolSize = allThreads.stream()
+                .filter(thread -> thread.wasStarted)
+                .count() == allThreads.size();
+
+        assertTrue(startedThreadCountEqualsPoolSize);
+    }
+}