trackler 2.2.1.45 → 2.2.1.46

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

@@ -2,7 +2,7 @@
 
 Count the rectangles in an ASCII diagram like the one below.
 
-```
+```text
    +--+
   ++  |
 +-++--+
@@ -12,7 +12,7 @@ Count the rectangles in an ASCII diagram like the one below.
 
 The above diagram contains 6 rectangles:
 
-```
+```text
 
 
 +-----+
@@ -20,7 +20,7 @@ The above diagram contains 6 rectangles:
 +-----+
 ```
 
-```
+```text
    +--+
    |  |
    |  |
@@ -28,7 +28,7 @@ The above diagram contains 6 rectangles:
    +--+
 ```
 
-```
+```text
    +--+
    |  |
    +--+
@@ -36,7 +36,7 @@ The above diagram contains 6 rectangles:
 
 ```
 
-```
+```text
        
        
    +--+
@@ -44,7 +44,7 @@ The above diagram contains 6 rectangles:
    +--+
 ```
 
-```
+```text
        
        
 +--+
@@ -52,7 +52,7 @@ The above diagram contains 6 rectangles:
 +--+
 ```
 
-```
+```text
        
   ++   
   ++   

data/tracks/java/exercises/rna-transcription/.meta/.version

@@ -0,0 +1 @@
+1.0.1

data/tracks/java/exercises/rna-transcription/src/test/java/RnaTranscriptionTest.java

@@ -6,9 +6,6 @@ import org.junit.rules.ExpectedException;
 
 import static org.junit.Assert.assertEquals;
 
-/*
- * version: 1.0.1
- */
 public class RnaTranscriptionTest {
 
     @Rule

data/tracks/java/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/java/exercises/rotational-cipher/README.md

@@ -13,7 +13,7 @@ The most commonly used rotational cipher is `ROT13`.
 
 A `ROT13` on the Latin alphabet would be as follows:
 
-```plain
+```text
 Plain:  abcdefghijklmnopqrstuvwxyz
 Cipher: nopqrstuvwxyzabcdefghijklm
 ```
@@ -23,6 +23,7 @@ It is stronger than the Atbash cipher because it has 27 possible keys, and 25 us
 Ciphertext is written out in the same formatting as the input including spaces and punctuation.
 
 ## Examples
+
 - ROT5  `omg` gives `trl`
 - ROT0  `c` gives `c`
 - ROT26 `Cool` gives `Cool`

data/tracks/java/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/java/exercises/saddle-points/.meta/.version

@@ -0,0 +1 @@
+1.0.0

data/tracks/java/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/java/exercises/saddle-points/src/test/java/MatrixTest.java

@@ -5,9 +5,6 @@ import java.util.*;
 
 import static org.junit.Assert.assertEquals;
 
-/*
- * version: 1.0.0
- */
 public class MatrixTest {
 
     @Test

data/tracks/java/exercises/scrabble-score/.meta/.version

@@ -0,0 +1 @@
+1.0.0

data/tracks/java/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/java/exercises/scrabble-score/src/test/java/ScrabbleScoreTest.java

@@ -7,9 +7,6 @@ import java.util.Collection;
 
 import static org.junit.Assert.assertEquals;
 
-/*
- * version: 1.0.0
- */
 @RunWith(Parameterized.class)
 public class ScrabbleScoreTest {
 

data/tracks/java/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/java/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/java/exercises/simple-linked-list/src/test/java/SimpleLinkedListTest.java

@@ -15,15 +15,15 @@ public class SimpleLinkedListTest {
 
     @Test
     public void aNewListIsEmpty() {
-        SimpleLinkedList list = new SimpleLinkedList();
+        SimpleLinkedList<Integer> list = new SimpleLinkedList<>();
         assertThat(list.size(), is(0));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void canCreateFromArray() {
-        Integer[] values = new Integer[]{1, 2, 3};
-        SimpleLinkedList list = new SimpleLinkedList(values);
+        Character[] values = new Character[]{'1', '2', '3'};
+        SimpleLinkedList<Character> list = new SimpleLinkedList<Character>(values);
         assertThat(list.size(), is(3));
     }
 
@@ -31,14 +31,14 @@ public class SimpleLinkedListTest {
     @Test
     public void popOnEmptyListWillThrow() {
         expectedException.expect(NoSuchElementException.class);
-        SimpleLinkedList list = new SimpleLinkedList();
+        SimpleLinkedList<String> list = new SimpleLinkedList<String>();
         list.pop();
     }
 
     @Ignore("Remove to run test")
     @Test
     public void popReturnsLastAddedElement() {
-        SimpleLinkedList list = new SimpleLinkedList();
+        SimpleLinkedList<Integer> list = new SimpleLinkedList<Integer>();
         list.push(9);
         list.push(8);
         assertThat(list.size(), is(2));
@@ -50,37 +50,37 @@ public class SimpleLinkedListTest {
     @Ignore("Remove to run test")
     @Test
     public void reverseReversesList() {
-        SimpleLinkedList list = new SimpleLinkedList();
-        list.push(9);
-        list.push(8);
-        list.push(7);
-        list.push(6);
-        list.push(5);
+        SimpleLinkedList<String> list = new SimpleLinkedList<String>();
+        list.push("9");
+        list.push("8");
+        list.push("7");
+        list.push("6");
+        list.push("5");
         list.reverse();
-        assertThat(list.pop(), is(9));
-        assertThat(list.pop(), is(8));
-        assertThat(list.pop(), is(7));
-        assertThat(list.pop(), is(6));
-        assertThat(list.pop(), is(5));
+        assertThat(list.pop(), is("9"));
+        assertThat(list.pop(), is("8"));
+        assertThat(list.pop(), is("7"));
+        assertThat(list.pop(), is("6"));
+        assertThat(list.pop(), is("5"));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void canReturnListAsArray() {
-        SimpleLinkedList list = new SimpleLinkedList();
-        list.push(9);
-        list.push(8);
-        list.push(7);
-        list.push(6);
-        list.push(5);
-        Integer[] expected = {5, 6, 7, 8, 9};
-        assertArrayEquals(expected, list.asArray(Integer.class));
+        SimpleLinkedList<Character> list = new SimpleLinkedList<Character>();
+        list.push('9');
+        list.push('8');
+        list.push('7');
+        list.push('6');
+        list.push('5');
+        Character[] expected = {'5', '6', '7', '8', '9'};
+        assertArrayEquals(expected, list.asArray(Character.class));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void canReturnEmptyListAsEmptyArray() {
-        SimpleLinkedList list = new SimpleLinkedList();
+        SimpleLinkedList<Object> list = new SimpleLinkedList<Object>();
         Object[] expected = {};
         assertArrayEquals(expected, list.asArray(Object.class));
     }

data/tracks/java/exercises/space-age/README.md

@@ -12,7 +12,7 @@ Given an age in seconds, calculate how old someone would be on:
    - Neptune: orbital period 164.79132 Earth years
 
 So if you were told someone were 1,000,000,000 seconds old, you should
-be able to say that they're 31 Earth-years old.
+be able to say that they're 31.69 Earth-years old.
 
 If you're wondering why Pluto didn't make the cut, go watch [this
 youtube video](http://www.youtube.com/watch?v=Z_2gbGXzFbs).

data/tracks/java/exercises/spiral-matrix/.meta/.version

@@ -0,0 +1 @@
+1.0.0

data/tracks/java/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/java/exercises/spiral-matrix/src/test/java/SpiralMatrixBuilderTest.java

@@ -4,9 +4,6 @@ import org.junit.Test;
 
 import static org.junit.Assert.assertArrayEquals;
 
-/*
- * version: 1.0.0
- */
 public class SpiralMatrixBuilderTest {
 
     private SpiralMatrixBuilder spiralMatrixBuilder;

data/tracks/java/exercises/sum-of-multiples/README.md

@@ -8,9 +8,6 @@ multiples of either 3 or 5, we get 3, 5, 6 and 9, 10, 12, 15, and 18.
 
 The sum of these multiples is 78.
 
-Given a number, find the sum of the multiples of a given set of numbers,
-up to but not including that number.
-
 
 To run the tests:
 

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

@@ -5,7 +5,7 @@ Tally the results of a small football competition.
 Based on an input file containing which team played against which and what the
 outcome was, create a file with a table like this:
 
-```
+```text
 Team                           | MP |  W |  D |  L |  P
 Devastating Donkeys            |  3 |  2 |  1 |  0 |  7
 Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6
@@ -31,7 +31,7 @@ Input
 
 Your tallying program will receive input that looks like:
 
-```
+```text
 Allegoric Alaskans;Blithering Badgers;win
 Devastating Donkeys;Courageous Californians;draw
 Devastating Donkeys;Allegoric Alaskans;win
@@ -42,7 +42,7 @@ Allegoric Alaskans;Courageous Californians;win
 
 The result of the match refers to the first team listed. So this line
 
-```
+```text
 Allegoric Alaskans;Blithering Badgers;win
 ```
 
@@ -50,7 +50,7 @@ Means that the Allegoric Alaskans beat the Blithering Badgers.
 
 This line:
 
-```
+```text
 Courageous Californians;Blithering Badgers;loss
 ```
 
@@ -58,7 +58,7 @@ Means that the Blithering Badgers beat the Courageous Californians.
 
 And this line:
 
-```
+```text
 Devastating Donkeys;Courageous Californians;draw
 ```
 
@@ -74,5 +74,6 @@ $ gradle test
 For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
 
 
+
 ## 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/transpose/README.md

@@ -4,14 +4,14 @@ Given an input text output it transposed.
 
 Roughly explained, the transpose of a matrix:
 
-```
+```text
 ABC
 DEF
 ```
 
 is given by:
 
-```
+```text
 AD
 BE
 CF
@@ -26,14 +26,14 @@ If the input has rows of different lengths, this is to be solved as follows:
 
 Therefore, transposing this matrix:
 
-```
+```text
 ABC
 DE
 ```
 
 results in:
 
-```
+```text
 AD
 BE
 C
@@ -41,21 +41,21 @@ C
 
 And transposing:
 
-```
+```text
 AB
 DEF
 ```
 
 results in:
 
-```
+```text
 AD
 BE
  F
 ```
 
 In general, all characters from the input should also be present in the transposed output.
-That means that if a column in the input text contains only spaces on its bottom-most row(s), 
+That means that if a column in the input text contains only spaces on its bottom-most row(s),
 the corresponding output row should contain the spaces in its right-most column(s).