trackler 2.2.1.40 → 2.2.1.41

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

@@ -14,24 +14,30 @@ product: `91 * 99 = 9009`.
 
 It's possible (and indeed common) for a palindrome product to be the product
 of multiple combinations of numbers. For example, the palindrome product `9` has
-the factors `(1, 9)`, `(3, 3)`, and `(9, 1)`.
+the factors `(1, 9)` and `(3, 3)`.
 
 Write a program that given a range of integers, returns the smallest and largest
-palindromic product within that range, along with all of it's factors.
+palindromic product of factors within that range, along with all the factors in the range for that product.
 
 ## Example 1
 
 Given the range `[1, 9]` (both inclusive)...
 
-The smallest product is `1`. It's factors are `(1, 1)`.
-The largest product is `9`. It's factors are `(1, 9)`, `(3, 3)`, and `(9, 1)`.
+And given the list of all possible products within this range:
+`[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 15, 21, 24, 27, 20, 28, 32, 36, 25, 30, 35, 40, 45, 42, 48, 54, 49, 56, 63, 64, 72, 81]`
+
+The palindrome products are all single digit numbers (in this case):
+`[1, 2, 3, 4, 5, 6, 7, 8, 9]`
+
+The smallest palindrome product is `1`. Its factors are `(1, 1)`.
+The largest palindrome product is `9`. Its factors are `(1, 9)` and `(3, 3)`.
 
 ## Example 2
 
 Given the range `[10, 99]` (both inclusive)...
 
-The smallest palindrome product is `121`. It's factors are `(11, 11)`.
-The largest palindrome product is `9009`. It's factors are `(91, 99)` and `(99, 91)`.
+The smallest palindrome product is `121`. Its factors are `(11, 11)`.
+The largest palindrome product is `9009`. Its factors are `(91, 99)`.
 
 ## Hints
 

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

@@ -2,7 +2,7 @@
 
 Determine if a sentence is a pangram. A pangram (Greek: παν γράμμα, pan gramma,
 "every letter") is a sentence using every letter of the alphabet at least once.
-The best known English pangram is: 
+The best known English pangram is:
 > The quick brown fox jumps over the lazy dog.
 
 The alphabet used consists of ASCII letters `a` to `z`, inclusive, and is case

data/tracks/haskell/exercises/pascals-triangle/README.md

@@ -1,11 +1,11 @@
-# Pascals Triangle
+# Pascal's Triangle
 
 Compute Pascal's triangle up to a given number of rows.
 
 In Pascal's Triangle each number is computed by adding the numbers to
 the right and left of the current position in the previous row.
 
-```plain
+```text
     1
    1 1
   1 2 1

data/tracks/haskell/exercises/phone-number/README.md

@@ -6,11 +6,12 @@ The **North American Numbering Plan (NANP)** is a telephone numbering system use
 
 NANP numbers are ten-digit numbers consisting of a three-digit Numbering Plan Area code, commonly known as *area code*, followed by a seven-digit local number. The first three digits of the local number represent the *exchange code*, followed by the unique four-digit number which is the *subscriber number*.
 
-
 The format is usually represented as
-```
+
+```text
 (NXX)-NXX-XXXX
 ```
+
 where `N` is any digit from 2 through 9 and `X` is any digit from 0 through 9.
 
 Your task is to clean up differently formated telephone numbers by removing punctuation and the country code (1) if present.

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

@@ -1,4 +1,4 @@
-# Pov
+# POV
 
 Reparent a graph on a selected node.
 
@@ -8,7 +8,7 @@ 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:
 
-```
+```text
     +------0------+
     |      |      |
   +-1-+  +-2-+  +-3-+
@@ -20,7 +20,7 @@ But the same information can be presented from the perspective of any other node
 in the graph, by pulling it up to the root and dragging its relationships along
 with it. So the same graph from 6's perspective would look like:
 
-```
+```text
         6
         |
   +-----2-----+

data/tracks/haskell/exercises/pythagorean-triplet/README.md

@@ -3,13 +3,13 @@
 A Pythagorean triplet is a set of three natural numbers, {a, b, c}, for
 which,
 
-```
+```text
 a**2 + b**2 = c**2
 ```
 
-For example, 
+For example,
 
-```
+```text
 3**2 + 4**2 = 9 + 16 = 25 = 5**2.
 ```
 

data/tracks/haskell/exercises/queen-attack/README.md

@@ -11,7 +11,7 @@ A chessboard can be represented by an 8 by 8 array.
 So if you're told the white queen is at (2, 3) and the black queen at
 (5, 6), then you'd know you've got a set-up like so:
 
-```plain
+```text
 _ _ _ _ _ _ _ _
 _ _ _ _ _ _ _ _
 _ _ _ W _ _ _ _

data/tracks/haskell/exercises/rna-transcription/README.md

@@ -1,4 +1,4 @@
-# Rna Transcription
+# RNA Transcription
 
 Given a DNA strand, return its RNA complement (per RNA transcription).
 

data/tracks/haskell/exercises/roman-numerals/README.md

@@ -14,7 +14,7 @@ The Romans wrote numbers using letters - I, V, X, L, C, D, M. (notice
 these letters have lots of straight lines and are hence easy to hack
 into stone tablets).
 
-```
+```text
  1  => I
 10  => X
  7  => VII

data/tracks/haskell/exercises/run-length-encoding/README.md

@@ -7,20 +7,20 @@ Run-length encoding (RLE) is a simple form of data compression, where runs
 
 For example we can represent the original 53 characters with only 13.
 
-```
+```text
 "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"  ->  "12WB12W3B24WB"
 ```
 
 RLE allows the original data to be perfectly reconstructed from
 the compressed data, which makes it a lossless data compression.
 
-```
+```text
 "AABCCCDEEEE"  ->  "2AB3CD4E"  ->  "AABCCCDEEEE"
 ```
 
 For simplicity, you can assume that the unencoded string will only contain
-the letters A through Z (either lower or upper case) and whitespace. This way 
-data to be encoded will never contain any numbers and numbers inside data to 
+the letters A through Z (either lower or upper case) and whitespace. This way
+data to be encoded will never contain any numbers and numbers inside data to
 be decoded always represent the count for the following character.
 
 

data/tracks/haskell/exercises/saddle-points/README.md

@@ -4,7 +4,7 @@ Detect saddle points in a matrix.
 
 So say you have a matrix like so:
 
-```plain
+```text
     0  1  2
   |---------
 0 | 9  8  7

data/tracks/haskell/exercises/scrabble-score/README.md

@@ -6,7 +6,7 @@ Given a word, compute the scrabble score for that word.
 
 You'll need these:
 
-```plain
+```text
 Letter                           Value
 A, E, I, O, U, L, N, R, S, T       1
 D, G                               2
@@ -18,6 +18,7 @@ Q, Z                               10
 ```
 
 ## Examples
+
 "cabbage" should be scored as worth 14 points:
 
 - 3 points for C
@@ -34,6 +35,7 @@ And to total:
 - = 14
 
 ## Extensions
+
 - You can play a double or a triple letter.
 - You can play a double or a triple word.
 

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

@@ -6,7 +6,7 @@
 You and your fellow cohort of those in the "know" when it comes to
 binary decide to come up with a secret "handshake".
 
-```
+```text
 1 = wink
 10 = double blink
 100 = close your eyes

data/tracks/haskell/exercises/sgf-parsing/README.md

@@ -1,4 +1,4 @@
-# Sgf Parsing
+# SGF Parsing
 
 Parsing a Smart Game Format string.
 
@@ -12,7 +12,7 @@ multiple values.
 
 An SGF file may look like this:
 
-```
+```text
 (;FF[4]C[root]SZ[19];B[aa];W[ab])
 ```
 
@@ -34,7 +34,7 @@ SGF can encode variations of play. Go players do a lot of backtracking
 in their reviews (let's try this, doesn't work, let's try that) and SGF
 supports variations of play sequences. For example:
 
-```
+```text
 (;FF[4](;B[aa];W[ab])(;B[dd];W[ee]))
 ```
 
@@ -46,7 +46,7 @@ opening to take the corner).
 
 A key can have multiple values associated with it. For example:
 
-```
+```text
 (;FF[4];AB[aa][ab][ba])
 ```
 

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

@@ -47,7 +47,7 @@ Given the key "aaaaaaaaaaaaaaaaaa", encoding the string "iamapandabear"
 would return the original "iamapandabear".
 
 Given the key "ddddddddddddddddd", encoding our string "iamapandabear"
-would return the obscured "lpdsdqgdehdu"
+would return the obscured "ldpdsdqgdehdu"
 
 In the example above, we've set a = 0 for the key value. So when the
 plaintext is added to the key, we end up with the same message coming

data/tracks/haskell/exercises/spiral-matrix/README.md

@@ -8,7 +8,7 @@ like these examples:
 
 ###### Spiral matrix of size 3
 
-```plain
+```text
 1 2 3
 8 9 4
 7 6 5
@@ -16,7 +16,7 @@ like these examples:
 
 ###### Spiral matrix of size 4
 
-```plain
+```text
  1  2  3 4
 12 13 14 5
 11 16 15 6

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

@@ -2,24 +2,27 @@
 
 Determine if a triangle is equilateral, isosceles, or scalene.
 
-An _equilateral_ triangle has all three sides the same length.<br/>
+An _equilateral_ triangle has all three sides the same length.
+
 An _isosceles_ triangle has at least two sides the same length. (It is sometimes
 specified as having exactly two sides the same length, but for the purposes of
-this exercise we'll say at least two.)<br/>
+this exercise we'll say at least two.)
+
 A _scalene_ triangle has all sides of different lengths.
 
 ## Note
 
-For a shape to be a triangle at all, all sides have to be of length > 0, and 
-the sum of the lengths of any two sides must be greater than or equal to the 
+For a shape to be a triangle at all, all sides have to be of length > 0, and
+the sum of the lengths of any two sides must be greater than or equal to the
 length of the third side. See [Triangle Inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
 
 ## Dig Deeper
 
-The case where the sum of the lengths of two sides _equals_ that of the 
-third is known as a _degenerate_ triangle - it has zero area and looks like 
+The case where the sum of the lengths of two sides _equals_ that of the
+third is known as a _degenerate_ triangle - it has zero area and looks like
 a single line. Feel free to add your own code/tests to check for degenerate triangles.
 
+
 ## Getting Started
 
 For installation and learning resources, refer to the

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

@@ -11,7 +11,7 @@ Trinary numbers contain three symbols: 0, 1, and 2.
 The last place in a trinary number is the 1's place. The second to last
 is the 3's place, the third to last is the 9's place, etc.
 
-```bash
+```shell
 # "102012"
     1       0       2       0       1       2    # the number
 1*3^5 + 0*3^4 + 2*3^3 + 0*3^2 + 1*3^1 + 2*3^0    # the value

data/tracks/haskell/exercises/word-count/README.md

@@ -4,14 +4,13 @@ Given a phrase, count the occurrences of each word in that phrase.
 
 For example for the input `"olly olly in come free"`
 
-```plain
+```text
 olly: 2
 in: 1
 come: 1
 free: 1
 ```
 
-
 ## Hints
 
 To complete this exercise you need to implement the function `wordCount`,

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

@@ -2,7 +2,6 @@
 
 Parse and evaluate simple math word problems returning the answer as an integer.
 
-
 ## Iteration 1 — Addition
 
 Add two numbers together.
@@ -13,7 +12,6 @@ Evaluates to 18.
 
 Handle large numbers and negative numbers.
 
-
 ## Iteration 2 — Subtraction, Multiplication and Division
 
 Now, perform the other three operations.
@@ -30,7 +28,6 @@ Now, perform the other three operations.
 
 5
 
-
 ## Iteration 3 — Multiple Operations
 
 Handle a set of operations, in sequence.
@@ -46,7 +43,6 @@ left-to-right, _ignoring the typical order of operations._
 
 15  (i.e. not 9)
 
-
 ## Bonus — Exponentials
 
 If you'd like, handle exponentials.
@@ -55,7 +51,6 @@ If you'd like, handle exponentials.
 
 32
 
-
 ## Hints
 
 This is a perfect opportunity to learn some Attoparsec or Parsec!

data/tracks/java/config.json

@@ -27,7 +27,11 @@
       "core": false,
       "difficulty": 2,
       "slug": "rna-transcription",
-      "topics": null,
+      "topics": [
+        "strings",
+        "loops",
+        "maps"
+      ],
       "unlocked_by": null,
       "uuid": "8e983ed2-62f7-439a-a144-fb8fdbdf4d30"
     },
@@ -153,7 +157,14 @@
       "core": false,
       "difficulty": 4,
       "slug": "luhn",
-      "topics": null,
+      "topics": [
+        "algorithms",
+        "booleans",
+        "loops",
+        "mathematics",
+        "strings",
+        "type_conversion"
+      ],
       "unlocked_by": "hamming",
       "uuid": "5227a76c-8ecb-4e5f-b023-6af65a057c41"
     },
@@ -252,7 +263,13 @@
       "core": false,
       "difficulty": 4,
       "slug": "diamond",
-      "topics": null,
+      "topics": [
+		"strings",
+		"loops",
+		"arrays",
+		"lists",
+		"text_formatting"
+		],
       "unlocked_by": "two-fer",
       "uuid": "ecbd997b-86f4-4e11-9ff0-706ac2899415"
     },
@@ -399,9 +416,11 @@
       "difficulty": 5,
       "slug": "series",
       "topics": [
+        "conditionals",
+        "lists",
         "loops",
-		    "strings",
-		    "conditionals"
+        "strings",
+        "type_conversion"
       ],
       "unlocked_by": "hamming",
       "uuid": "af80d7f4-c7d0-4d0b-9c30-09da120f6bb9"
@@ -426,7 +445,14 @@
       "core": false,
       "difficulty": 6,
       "slug": "roman-numerals",
-      "topics": null,
+      "topics": [
+        "logic",
+        "mathematics",
+        "loops",
+        "integers",
+        "strings",
+        "maps"
+      ],
       "unlocked_by": "hamming",
       "uuid": "3e728cd4-5e5f-4c69-8a53-bc36d020fcdb"
     },
@@ -476,7 +502,14 @@
       "core": false,
       "difficulty": 6,
       "slug": "queen-attack",
-      "topics": null,
+      "topics": [
+        "arrays",
+        "matrices",
+        "conditionals",
+        "classes",
+        "games",
+        "mathematics"
+      ],
       "unlocked_by": "scrabble-score",
       "uuid": "5404109e-3ed9-4691-8eaf-af8b36024a44"
     },
@@ -524,7 +557,14 @@
       "core": false,
       "difficulty": 6,
       "slug": "minesweeper",
-      "topics": null,
+      "topics": [
+        "integers",
+        "matrices",
+        "games",
+        "conditionals",
+        "strings",
+        "lists"
+      ],
       "unlocked_by": "scrabble-score",
       "uuid": "416a1489-12af-4593-8540-0f55285c96b4"
     },
@@ -587,7 +627,14 @@
       "core": false,
       "difficulty": 7,
       "slug": "word-search",
-      "topics": null,
+      "topics": [
+        "strings",
+        "games",
+        "logic",
+        "matrices",
+        "searching",
+        "pattern_matching"
+      ],
       "unlocked_by": "scrabble-score",
       "uuid": "b53bde52-cb5f-4d43-86ec-18aa509d62f9"
     },

data/tracks/java/exercises/binary-search-tree/src/test/java/BSTTest.java

@@ -11,7 +11,7 @@ public class BSTTest {
 
     @Test
     public void dataIsRetained() {
-        BST<Integer> bst = new BST();
+        BST<Integer> bst = new BST<>();
         final int actual = 4;
         bst.insert(actual);
         final BST.Node<Integer> root = bst.getRoot();
@@ -23,7 +23,7 @@ public class BSTTest {
     @Ignore("Remove to run test")
     @Test
     public void insertsLess() {
-        BST<Integer> bst = new BST();
+        BST<Integer> bst = new BST<>();
         final int expectedRoot = 4;
         final int expectedLeft = 2;
 
@@ -44,7 +44,7 @@ public class BSTTest {
     @Ignore("Remove to run test")
     @Test
     public void insertsSame() {
-        BST<Integer> bst = new BST();
+        BST<Integer> bst = new BST<>();
         final int expectedRoot = 4;
         final int expectedLeft = 4;
 
@@ -65,7 +65,7 @@ public class BSTTest {
     @Ignore("Remove to run test")
     @Test
     public void insertsRight() {
-        BST<Integer> bst = new BST();
+        BST<Integer> bst = new BST<>();
         final int expectedRoot = 4;
         final int expectedRight = 5;