trackler 2.2.1.103 → 2.2.1.104

data/tracks/go/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).
 
 ## Running the tests

data/tracks/go/exercises/tree-building/README.md

@@ -11,12 +11,12 @@ Your job will be to refactor a working but slow and ugly piece of code that
 implements the tree building logic for highly abstracted records. The records
 only contain an ID number and a parent ID number. The ID number is always
 between 0 (inclusive) and the length of the record list (exclusive). All records
-have a parent ID lower than their own ID, except for the root record, which has 
+have a parent ID lower than their own ID, except for the root record, which has
 a parent ID that's equal to its own ID.
 
 An example tree:
 
-<pre>
+```text
 root (ID: 0, parent ID: 0)
 |-- child1 (ID: 1, parent ID: 0)
 |    |-- grandchild1 (ID: 2, parent ID: 1)
@@ -24,7 +24,7 @@ root (ID: 0, parent ID: 0)
 +-- child2 (ID: 3, parent ID: 0)
 |    +-- grandchild3 (ID: 6, parent ID: 3)
 +-- child3 (ID: 5, parent ID: 0)
-</pre>
+```
 
 ## Running the tests
 
@@ -43,6 +43,5 @@ different specs, so the results from these benchmark tests may vary.
 For more detailed information about the Go track, including how to get help if
 you're having trouble, please visit the exercism.io [Go language page](http://exercism.io/languages/go/about).
 
-
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -2,23 +2,38 @@
 
 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.
+
+## Constant Declarations
+
+In this exercise you are asked to declare a series of constants used to identify
+different types of triangles. Pick the data type you think works best for this
+and get the tests passing.
+
+Afterwards, it may be worth reading about Go's
+predeclared identifier [iota](https://golang.org/ref/spec#Iota). There's an
+excellent write up about it
+[here](https://splice.com/blog/iota-elegant-constants-golang/).
+
+
 ## Running the tests
 
 To run the tests run the command `go test` from within the exercise directory.

data/tracks/go/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/go/exercises/twelve-days/README.md

@@ -2,7 +2,7 @@
 
 Output the lyrics to 'The Twelve Days of Christmas'.
 
-```
+```text
 On the first day of Christmas my true love gave to me, a Partridge in a Pear Tree.
 
 On the second day of Christmas my true love gave to me, two Turtle Doves, and a Partridge in a Pear Tree.
@@ -47,8 +47,7 @@ you're having trouble, please visit the exercism.io [Go language page](http://ex
 
 ## Source
 
-Wikipedia [http://en.wikipedia.org/wiki/The*Twelve_Days_of_Christmas*(song)](<http://en.wikipedia.org/wiki/The_Twelve_Days_of_Christmas_(song)>)
+Wikipedia [http://en.wikipedia.org/wiki/The_Twelve_Days_of_Christmas_(song)](http://en.wikipedia.org/wiki/The_Twelve_Days_of_Christmas_(song))
 
 ## Submitting Incomplete Solutions
-
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/go/exercises/two-fer/README.md

@@ -2,7 +2,7 @@
 
 `Two-fer` or `2-fer` is short for two for one. One for you and one for me.
 
-```
+```text
 "One for X, one for me."
 ```
 
@@ -12,35 +12,6 @@ If the given name is "Alice", the result should be "One for Alice, one for me."
 If no name is given, the result should be "One for you, one for me."
 
 
-## Test-Driven Development
-
-As programmers mature, they eventually want to test their code.
-
-Here at Exercism we simulate [Test-Driven
-Development](http://en.wikipedia.org/wiki/Test-driven_development) (TDD), where
-you write your tests before writing any functionality. The simulation comes in
-the form of a pre-written test suite, which will signal that you have solved
-the problem.
-
-It will also provide you with a safety net to explore other solutions without
-breaking the functionality.
-
-### A typical TDD workflow on Exercism:
-
-1. Run the test file and pick one test that's failing.
-2. Write some code to fix the test you picked.
-3. Re-run the tests to confirm the test is now passing.
-4. Repeat from step 1.
-5. Submit your solution (`exercism submit /path/to/file`)
-
-## Instructions
-
-Submissions are encouraged to be general, within reason. Having said that, it's
-also important not to over-engineer a solution.
-
-It's important to remember that the goal is to make code as expressive and
-readable as we can.
-
 ## Running the tests
 
 To run the tests run the command `go test` from within the exercise directory.
@@ -60,7 +31,7 @@ you're having trouble, please visit the exercism.io [Go language page](http://ex
 
 ## Source
 
-This is an exercise to introduce users to basic programming constructs, just after hello World. [https://en.wikipedia.org/wiki/Two-fer](https://en.wikipedia.org/wiki/Two-fer)
+[https://en.wikipedia.org/wiki/Two-fer](https://en.wikipedia.org/wiki/Two-fer)
 
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/go/exercises/variable-length-quantity/README.md

@@ -5,18 +5,17 @@ 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. 
+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. 
+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. 
+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

data/tracks/go/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
 ```
 
-
 ## Running the tests
 
 To run the tests run the command `go test` from within the exercise directory.

data/tracks/go/exercises/word-search/README.md

@@ -5,7 +5,7 @@ words in them.
 
 For example:
 
-```
+```text
 jefblpepre
 camdcimgtc
 oivokprjsm
@@ -43,6 +43,5 @@ different specs, so the results from these benchmark tests may vary.
 For more detailed information about the Go track, including how to get help if
 you're having trouble, please visit the exercism.io [Go language page](http://exercism.io/languages/go/about).
 
-
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/go/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
 
-
 ## Running the tests
 
 To run the tests run the command `go test` from within the exercise directory.

data/tracks/groovy/config.json

@@ -195,6 +195,17 @@
     },
     {
       "core": true,
+      "difficulty": 4,
+      "slug": "rotational-cipher",
+      "topics": [
+        "cryptography",
+        "integers",
+        "strings"
+      ],
+      "unlocked_by": null,
+      "uuid": "449fc372-ba30-4c45-99b4-8053e9cdf502"
+    },
+    {
       "difficulty": 5,
       "slug": "flatten-array",
       "topics": [

data/tracks/groovy/exercises/rotational-cipher/Example.groovy

@@ -0,0 +1,38 @@
+public class RotationalCipher {
+    private int key
+
+    public RotationalCipher(int key) {
+        this.key = key
+    }
+
+    public String rotate(String cipherText) {
+        StringBuilder ret = new StringBuilder()
+        cipherText.each { c -> ret.append(convert(c)) }
+        ret.toString()
+    }
+
+    /*
+     * 'a' == 97
+     * 'z' == 122
+     * 'A' == 65
+     * 'Z' == 90
+     * For reference, see http://www.asciitable.com
+     */
+    private char convert(String s) {
+        char c = s as Character
+        int cInt = c as Integer
+        int convertedInt = cInt + key
+        if(c.isLetter()) {
+            if(c.isLowerCase() && convertedInt > 122) {
+                (96 + (convertedInt % 122)) as Character
+            } else if (c.isUpperCase() && convertedInt > 90){
+                (64 + (convertedInt % 90)) as Character
+            } else {
+                convertedInt as Character
+            }
+        } else {
+            c
+        }
+
+    }
+}

data/tracks/groovy/exercises/rotational-cipher/README.md

@@ -0,0 +1,49 @@
+# Rotational Cipher
+
+Create an implementation of the rotational cipher, also sometimes called the Caesar cipher.
+
+The Caesar cipher is a simple shift cipher that relies on
+transposing all the letters in the alphabet using an integer key
+between `0` and `26`. Using a key of `0` or `26` will always yield
+the same output due to modular arithmetic. The letter is shifted
+for as many values as the value of the key.
+
+The general notation for rotational ciphers is `ROT + <key>`.
+The most commonly used rotational cipher is `ROT13`.
+
+A `ROT13` on the Latin alphabet would be as follows:
+
+```text
+Plain:  abcdefghijklmnopqrstuvwxyz
+Cipher: nopqrstuvwxyzabcdefghijklm
+```
+
+It is stronger than the Atbash cipher because it has 27 possible keys, and 25 usable keys.
+
+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`
+- ROT13 `The quick brown fox jumps over the lazy dog.` gives `Gur dhvpx oebja sbk whzcf bire gur ynml qbt.`
+- ROT13 `Gur dhvpx oebja sbk whzcf bire gur ynml qbt.` gives `The quick brown fox jumps over the lazy dog.`
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ groovy ./RotationalCipherSpec.groovy
+```
+
+in your terminal.
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Caesar_cipher](https://en.wikipedia.org/wiki/Caesar_cipher)
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/groovy/exercises/rotational-cipher/RotationalCipher.groovy

@@ -0,0 +1,11 @@
+class RotationalCipher {
+    private int key
+
+    public RotationalCipher(int key) {
+        this.key = key
+    }
+
+    public String rotate(String cipherText) {
+        throw new UnsupportedOperationException('Method implementation is missing')
+    }
+}

data/tracks/groovy/exercises/rotational-cipher/RotationalCipherSpec.groovy

@@ -0,0 +1,68 @@
+@Grab('org.spockframework:spock-core:1.0-groovy-2.4')
+import spock.lang.*
+
+class RotationalCipherSpec extends Specification {
+private RotationalCipher
+    private RotationalCipher rotationalCipher
+
+    def 'rotate single character by 1'() {
+        rotationalCipher = new RotationalCipher(1)
+        expect: rotationalCipher.rotate("a") == "b"
+    }
+
+    @Ignore
+    def 'rotate single character by 26'() {
+        rotationalCipher = new RotationalCipher(26)
+        expect: rotationalCipher.rotate("a") == "a"
+    }
+
+    @Ignore
+    def 'rotate single character by 0'() {
+        rotationalCipher = new RotationalCipher(0)
+        expect: rotationalCipher.rotate("a") == "a"
+    }
+
+    @Ignore
+    def 'rotate single character with wrap around'() {
+        rotationalCipher = new RotationalCipher(13)
+        expect: rotationalCipher.rotate("n") == "a"
+    }
+
+    @Ignore
+    def 'rotate capital letters'() {
+        rotationalCipher = new RotationalCipher(5)
+        expect: rotationalCipher.rotate("OMG") == "TRL"
+    }
+
+    @Ignore
+    def 'rotate spaces'() {
+        rotationalCipher = new RotationalCipher(5)
+        expect: rotationalCipher.rotate("O M G") == "T R L"
+    }
+
+    @Ignore
+    def 'rotate numbers'() {
+        rotationalCipher = new RotationalCipher(4)
+        expect:
+            rotationalCipher.rotate("Testing 1 2 3 testing") ==
+            "Xiwxmrk 1 2 3 xiwxmrk"
+    }
+
+    @Ignore
+    def 'rotate punctuation'() {
+        rotationalCipher = new RotationalCipher(21)
+        expect:
+            rotationalCipher.rotate("Let's eat, Grandma!") ==
+            "Gzo'n zvo, Bmviyhv!"
+    }
+
+    @Ignore
+    def 'rotate all letters'() {
+        rotationalCipher = new RotationalCipher(13)
+        expect:
+            rotationalCipher.rotate(
+                "Gur dhvpx oebja sbk whzcf bire gur ynml qbt.") ==
+                "The quick brown fox jumps over the lazy dog."
+    }
+
+}