trackler 2.2.1.83 → 2.2.1.84

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd3db94a01e41282f6733f0e8356e7781580009a
-  data.tar.gz: 25464cb3caef3b9481c20cea3a1e3667d8ffee6b
+  metadata.gz: d3ec763db2b39453f204556765096d8b89410636
+  data.tar.gz: 0b10a5133a6d4f9fa08142ae215484fd257b8bc7
 SHA512:
-  metadata.gz: bb80d176aca640ed2e83cd55815849ff454d6184118095d1af15168bdaedbdb6abeae8dd94e527922e2945e7913f249018ecf38b9d1e3b19de6be8b915cde5c6
-  data.tar.gz: e54cbb2d9efcac874d7aacba8ed97a916adb53c639e3f01f212e08685fbeaa3fbd5bdbb84e3ec666f2b1df70cc1023af18aaaa8efc545dd24ffbc020c74afd20
+  metadata.gz: 136ccecbe72a54b7da0c44b660a02b8dbe4e0304d0e42360f71f53937617221936a011a525b5f6ccd00f98e7ba969b7ddf52f8c16d4725c247a80d078c3731ce
+  data.tar.gz: 3d20a2d47b630cc688667dc3ad626e13c603f50c61a969b19a4059cc3a4ed61b74d72a7ef57ac09340cfb84d8d9502f9a637e1b4e88f8f61b15611010d561639

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.83"
+  VERSION = "2.2.1.84"
 end

data/tracks/bash/config.json

@@ -51,6 +51,17 @@
       ],
       "uuid": "e24451fd-761d-4d20-81d9-e470486ec44a"
     },
+    {
+      "core": true,
+      "difficulty": 1,
+      "slug": "grains",
+      "topics": [
+        "control_flow_conditionals",
+        "input_validation",
+        "mathematics"
+      ],
+      "uuid": "c9d36155-10e8-4a75-a732-3c43a68910eb"
+    },
     {
       "core": false,
       "difficulty": 1,
@@ -182,6 +193,19 @@
       "unlocked_by": "pangram",
       "uuid": "51bd6542-408b-4a73-8343-1c4d50db5315"
     },
+    {
+      "core": false,
+      "difficulty": 2,
+      "slug": "triangle",
+      "topics": [
+        "boolean_logic",
+        "input_validation",
+        "number_comparison",
+        "mathematics"
+      ],
+      "unlocked_by": "leap",
+      "uuid": "0f79f9ab-4a51-468c-88ca-84f0bf7cfc38"
+    },
     {
       "core": false,
       "difficulty": 2,
@@ -195,16 +219,29 @@
     },
     {
       "core": false,
-      "difficulty": 2,
-      "slug": "triangle",
+      "difficulty": 3,
+      "slug": "luhn",
       "topics": [
-        "boolean_logic",
+        "algorithms",
+        "control_flow_conditionals",
+        "integers",
+        "mathematics"
+      ],
+      "unlocked_by": "difference-of-squares",
+      "uuid": "a3b16d02-2963-445d-9339-7e3002375a71"
+    },
+    {
+      "core": false,
+      "difficulty": 3,
+      "slug": "collatz-conjecture",
+      "topics": [
+        "control_flow_conditionals",
         "input_validation",
-        "number_comparison",
+        "integers",
         "mathematics"
       ],
-      "unlocked_by": "leap",
-      "uuid": "bd8fd05e-3f8d-4a1f-a9d8-e6223dcc6f93"
+      "unlocked_by": "armstrong-numbers",
+      "uuid": "b4793e6d-f443-41ea-8289-95e18a5dbef4"
     },
     {
       "core": false,

data/tracks/bash/exercises/collatz-conjecture/README.md

@@ -0,0 +1,34 @@
+# Collatz Conjecture 
+
+The Collatz Conjecture or 3x+1 problem can be summarized as follows:
+
+Take any positive integer n. If n is even, divide n by 2 to get n / 2. If n is
+odd, multiply n by 3 and add 1 to get 3n + 1. Repeat the process indefinitely.
+The conjecture states that no matter which number you start with, you will
+always reach 1 eventually.
+
+Given a number n, return the number of steps required to reach 1.
+
+## Examples
+
+Starting with n = 12, the steps would be as follows:
+
+0. 12
+1. 6
+2. 3
+3. 10
+4. 5
+5. 16
+6. 8
+7. 4
+8. 2
+9. 1
+
+Resulting in 9 steps. So for input n = 12, the return value would be 9.
+
+## Source
+
+An unsolved problem in mathematics named after mathematician Lothar Collatz [Wikipedia](https://en.wikipedia.org/wiki/3x_%2B_1_problem)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/bash/exercises/collatz-conjecture/collatz_test.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bats
+
+@test "zero steps for one" {
+  #skip
+  run bash collatz.sh 1
+
+  [ "$status" -eq 0 ]
+  [ "$output" -eq 0 ]
+}
+
+@test "divide if even" {
+  skip
+  run bash collatz.sh 16
+
+  [ "$status" -eq 0 ]
+  [ "$output" -eq 4 ]
+}
+
+@test "even and odd steps" {
+  skip
+  run bash collatz.sh 12
+
+  [ "$status" -eq 0 ]
+  [ "$output" -eq 9 ]
+}
+
+@test "large number of even and odd steps" {
+  skip
+  run bash collatz.sh 1000000
+
+  [ "$status" -eq 0 ]
+  [ "$output" -eq 152 ]
+}
+
+@test "zero is an error" {
+  skip
+  run bash collatz.sh 0
+
+  [ "$status" -eq 1 ]
+  [ "$output" == "Error: Only positive numbers are allowed" ]
+}
+
+@test "negative value is an error" {
+  skip
+  run bash collatz.sh -15
+
+  [ "$status" -eq 1 ]
+  [ "$output" == "Error: Only positive numbers are allowed" ]
+}

data/tracks/bash/exercises/collatz-conjecture/example.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+if [ "$1" -gt 0 ]; then
+    N=$1
+else
+    echo "Error: Only positive numbers are allowed"
+    exit 1
+fi
+
+STEP=0
+
+while [ "$N" -ne "1" ]
+do
+    if [ "$(($N % 2))" -eq "0" ]; then
+        N=$(($N / 2))
+    else
+        N=$((($N * 3) + 1))
+    fi
+    STEP=$(($STEP + 1))
+done
+
+echo $STEP

data/tracks/bash/exercises/grains/README.md

@@ -0,0 +1,35 @@
+# Grains
+
+Calculate the number of grains of wheat on a chessboard given that the number
+on each square doubles.
+
+There once was a wise servant who saved the life of a prince. The king
+promised to pay whatever the servant could dream up. Knowing that the
+king loved chess, the servant told the king he would like to have grains
+of wheat. One grain on the first square of a chess board. Two grains on
+the next. Four on the third, and so on.
+
+There are 64 squares on a chessboard.
+
+Write code that shows:
+- how many grains were on each square, and
+- the total number of grains
+
+## For bonus points
+
+Did you get the tests passing and the code clean? If you want to, these
+are some additional things you could try:
+
+- Optimize for speed.
+- Optimize for readability.
+
+Then please share your thoughts in a comment on the submission. Did this
+experiment make the code better? Worse? Did you learn anything from it?
+
+## Source
+
+Calculate the number of grains of wheat on a chessboard given that the number on each square doubles. [JavaRanch Cattle Drive, exercise 6](http://www.javaranch.com/grains.jsp) 
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/bash/exercises/grains/example.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+if [[ "$1" -lt 1  || "$1" -gt 64  ]];
+then
+    echo "Error: invalid input"
+    exit 1;
+else
+    index=$(($1-1))
+    echo "2^$index" | bc;
+fi;

data/tracks/bash/exercises/grains/grains_test.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bats
+
+@test "Square 1" {
+  #skip
+  run bash grains.sh 1
+
+  [ "$status" -eq 0 ]
+  [ "$output" = "1" ]
+}
+
+@test "Square 2" {
+  #skip
+  run bash grains.sh 2
+
+  [ "$status" -eq 0 ]
+  [ "$output" = "2" ]
+}
+
+@test "Square 3" {
+  #skip
+  run bash grains.sh 3
+
+  [ "$status" -eq 0 ]
+  [ "$output" = "4" ]
+}
+
+@test "Square 4" {
+  #skip
+  run bash grains.sh 4
+
+  [ "$status" -eq 0 ]
+  [ "$output" = "8" ]
+}
+
+@test "Square 16" {
+  #skip
+  run bash grains.sh 16
+
+  [ "$status" -eq 0 ]
+  [ "$output" = "32768" ]
+}
+
+@test "Square 32" {
+  #skip
+  run bash grains.sh 32
+
+  [ "$status" -eq 0 ]
+  [ "$output" = "2147483648" ]
+}
+
+@test "Square 64" {
+  #skip
+  run bash grains.sh 64
+
+  [ "$status" -eq 0 ]
+  [ "$output" = "9223372036854775808" ]
+}
+
+@test "Square 0 causes error" {
+  #skip
+  run bash grains.sh 0
+
+  [ "$status" -eq 1 ]
+  [ "$output" = "Error: invalid input" ]
+}
+
+@test "Square -1 causes error" {
+  #skip
+  run bash grains.sh -1
+
+  [ "$status" -eq 1 ]
+  [ "$output" = "Error: invalid input" ]
+}
+
+@test "Square 65 causes error" {
+  #skip
+  run bash grains.sh 65
+
+  [ "$status" -eq 1 ]
+  [ "$output" = "Error: invalid input" ]
+}

data/tracks/bash/exercises/luhn/README.md

@@ -0,0 +1,76 @@
+# Luhn
+
+Given a number determine whether or not it is valid per the Luhn formula.
+
+The [Luhn algorithm](https://en.wikipedia.org/wiki/Luhn_algorithm) is
+a simple checksum formula used to validate a variety of identification
+numbers, such as credit card numbers and Canadian Social Insurance
+Numbers.
+
+The task is to check if a given string is valid.
+
+Validating a Number
+------
+
+Strings of length 1 or less are not valid. Spaces are allowed in the input,
+but they should be stripped before checking. All other non-digit characters
+are disallowed.
+
+## Example 1: valid credit card number
+
+```text
+4539 1488 0343 6467
+```
+
+The first step of the Luhn algorithm is to double every second digit,
+starting from the right. We will be doubling
+
+```text
+4_3_ 1_8_ 0_4_ 6_6_
+```
+
+If doubling the number results in a number greater than 9 then subtract 9
+from the product. The results of our doubling:
+
+```text
+8569 2478 0383 3437
+```
+
+Then sum all of the digits:
+
+```text
+8+5+6+9+2+4+7+8+0+3+8+3+3+4+3+7 = 80
+```
+
+If the sum is evenly divisible by 10, then the number is valid. This number is valid!
+
+## Example 2: invalid credit card number
+
+```text
+8273 1232 7352 0569
+```
+
+Double the second digits, starting from the right
+
+```text
+7253 2262 5312 0539
+```
+
+Sum the digits
+
+```text
+7+2+5+3+2+2+6+2+5+3+1+2+0+5+3+9 = 57
+```
+
+57 is not evenly divisible by 10, so this number is not valid.
+
+Run the tests with:
+
+    bats whatever_test.sh
+
+## Source
+
+The Luhn Algorithm on Wikipedia [Wikipedia](http://en.wikipedia.org/wiki/Luhn_algorithm)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/bash/exercises/luhn/example.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+num=$(echo "$1" | sed 's/[\ ]//g')
+
+if ! [[ 10#$num -ge 0 ]] 2>/dev/null || ! [[ ${#num} -gt 1 ]] ; then
+    echo "false"
+else
+    shift 1
+
+    len=${#num}
+    is_odd=1
+    sum=0
+
+    for((t = len - 1; t >= 0; --t)) {
+        digit=${num:$t:1}
+
+        if [[ $is_odd -eq 1 ]]; then
+            sum=$(( sum + $digit ))
+        else
+            sum=$(( $sum + ( $digit != 9 ? ( ( 2 * $digit ) % 9 ) : 9 ) ))
+        fi
+
+        is_odd=$(( ! $is_odd ))
+    }
+
+    if [[ 0 -eq $(( 0 != ( $sum % 10 ) )) ]] ; then
+        echo "true"
+    else
+        echo "false"
+    fi
+
+fi

data/tracks/bash/exercises/luhn/luhn_test.sh

@@ -0,0 +1,105 @@
+#!/usr/bin/env bats
+
+@test "single digit strings cannot be valid" {
+  #skip
+  run bash luhn.sh "1"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "false" ]
+}
+
+@test "a single zero is invalid" {
+  #skip
+  run bash luhn.sh "0"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "false" ]
+}
+
+@test "a simple valid SIN that remains valid if reversed" {
+  #skip
+  run bash luhn.sh "059"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "true" ]
+}
+
+@test "a simple valid SIN that becomes invalid if reversed" {
+  #skip
+  run bash luhn.sh "59"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "true" ]
+}
+
+@test "a valid Canadian SIN" {
+  #skip
+  run bash luhn.sh "055 444 285"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "true" ]
+}
+
+@test "invalid Canadian SID" {
+  #skip
+  run bash luhn.sh "055 444 286"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "false" ]
+}
+
+@test "invalid credit card" {
+  #skip
+  run bash luhn.sh "8273 1232 7352 0569"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "false" ]
+}
+
+@test "valid strings with a non-digit included become invalid" {
+  #skip
+  run bash luhn.sh "055a 444 285"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "false" ]
+}
+
+@test "valid strings with punctuation included become invalid" {
+  #skip
+  run bash luhn.sh "055-444-285"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "false" ]
+}
+
+@test "valid strings with symbols included become invalid" {
+  #skip
+  run bash luhn.sh "055£ 444$ 285"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "false" ]
+}
+
+@test "single zero with space is invalid" {
+  #skip
+  run bash luhn.sh " 0"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "false" ]
+}
+
+@test "more than a single zero is valid" {
+  #skip
+  run bash luhn.sh "0000 0"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "true" ]
+}
+
+@test "input digit 9 is correctly converted to output digit 9" {
+  #skip
+  run bash luhn.sh "091"
+
+  [ "$status" -eq 0 ]
+  [ "$output" == "true" ]
+}

data/tracks/clojure/config.json

@@ -17,6 +17,14 @@
       "unlocked_by": null,
       "uuid": "a4bdbdfd-1db1-425c-a243-dd032dc7b93a"
     },
+    {
+      "core": false,
+      "difficulty": 1,
+      "slug": "two-fer",
+      "topics": null,
+      "unlocked_by": null,
+      "uuid": "91a1f32c-0dac-4c65-8a13-49da90d21520"
+    },
     {
       "core": false,
       "difficulty": 1,
@@ -585,4 +593,4 @@
   ],
   "foregone": [],
   "language": "Clojure"
-} 
+}

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

@@ -0,0 +1,19 @@
+# Two-fer
+
+`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."
+```
+
+When X is a name or "you".
+
+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."
+
+## Source
+
+This is an exercise to introduce users to basic programming constructs, just after hello World. [http://en.wikipedia.org/wiki/Two-fer](http://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/clojure/exercises/two-fer/project.clj

@@ -0,0 +1,4 @@
+(defproject two-fer "0.1.0-SNAPSHOT"
+  :description "two-fer exercise."
+  :url "https://github.com/exercism/clojure/tree/master/exercises/two-fer"
+  :dependencies [[org.clojure/clojure "1.8.0"]])

data/tracks/clojure/exercises/two-fer/src/example.clj

@@ -0,0 +1,5 @@
+(ns two-fer)
+
+(defn two-fer 
+  ([] (str "One for you, one for me."))
+  ([name] (str "One for " name ", one for me.")))

data/tracks/clojure/exercises/two-fer/src/two_fer.clj

@@ -0,0 +1,5 @@
+(ns two-fer)
+
+(defn two-fer [] ;; <- arglist goes here
+  ;; your code goes here
+)

data/tracks/clojure/exercises/two-fer/test/two_fer_test.clj

@@ -0,0 +1,12 @@
+(ns two-fer-test
+  (:require [clojure.test :refer [deftest is]]
+            two-fer))
+
+(deftest two-fer-test
+  (is (= "One for you, one for me." (two-fer/two-fer))))
+
+(deftest name-alice-test
+  (is (= "One for Alice, one for me." (two-fer/two-fer "Alice"))))
+
+(deftest name-bob-test
+  (is (= "One for Bob, one for me." (two-fer/two-fer "Bob"))))

data/tracks/python/config.json

@@ -1298,9 +1298,11 @@
       "uuid": "6b7f7b1f-c388-4f4c-b924-84535cc5e1a0",
       "slug": "hexadecimal",
       "deprecated": true
+    },
+    {
+      "uuid": "da03fca4-4606-48d8-9137-6e40396f7759",
+      "slug": "parallel-letter-frequency",
+      "deprecated": true
     }
-  ],
-  "foregone": [
-      "parallel-letter-frequency"
   ]
 }

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

@@ -0,0 +1,36 @@
+# 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.
+
+## Exception messages
+
+Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to
+indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not
+every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include
+a message.
+
+To raise a message with an exception, just write it as an argument to the exception type. For example, instead of
+`raise Exception`, you shold write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+
+## Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
+
+For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/python).
+
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/python/exercises/parallel-letter-frequency/example.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+from collections import Counter
+from threading import Lock, Thread
+from time import sleep
+import sys
+if sys.version[0] == '2':
+    from Queue import Queue
+else:
+    from queue import Queue
+
+total_workers = 3  # Maximum number of threads chosen arbitrarily
+
+
+class LetterCounter(object):
+
+    def __init__(self):
+        self.lock = Lock()
+        self.value = Counter()
+
+    def add_counter(self, counter_to_add):
+        self.lock.acquire()
+        try:
+            self.value = self.value + counter_to_add
+        finally:
+            self.lock.release()
+
+
+def count_letters(queue_of_texts, letter_to_frequency, worker_id):
+    while not queue_of_texts.empty():
+        sleep(worker_id + 1)
+        line_input = queue_of_texts.get()
+        if line_input is not None:
+            letters_in_line = Counter([x for x in line_input.lower() if
+                                       x.isalpha()])
+            letter_to_frequency.add_counter(letters_in_line)
+        queue_of_texts.task_done()
+        if line_input is None:
+            break
+
+
+def calculate(list_of_texts):
+    queue_of_texts = Queue()
+    [queue_of_texts.put(line) for line in list_of_texts]
+    letter_to_frequency = LetterCounter()
+    threads = []
+    for i in range(total_workers):
+        worker = Thread(target=count_letters, args=(queue_of_texts,
+                                                    letter_to_frequency, i))
+        worker.start()
+        threads.append(worker)
+    queue_of_texts.join()
+    for i in range(total_workers):
+        queue_of_texts.put(None)
+    for t in threads:
+        t.join()
+    return letter_to_frequency.value

data/tracks/python/exercises/parallel-letter-frequency/parallel_letter_frequency.py

@@ -0,0 +1,2 @@
+def calculate(text_input):
+    pass

data/tracks/python/exercises/parallel-letter-frequency/parallel_letter_frequency_test.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+from collections import Counter
+import unittest
+
+from parallel_letter_frequency import calculate
+
+
+class ParallelLetterFrequencyTest(unittest.TestCase):
+    def test_one_letter(self):
+        actual = calculate(['a'])
+        expected = {'a': 1}
+        self.assertDictEqual(actual, expected)
+
+    def test_case_insensitivity(self):
+        actual = calculate(['aA'])
+        expected = {'a': 2}
+        self.assertDictEqual(actual, expected)
+
+    def test_numbers(self):
+        actual = calculate(['012', '345', '6789'])
+        expected = {}
+        self.assertDictEqual(actual, expected)
+
+    def test_punctuations(self):
+        actual = calculate(['[]\;,', './{}|', ':"<>?'])
+        expected = {}
+        self.assertDictEqual(actual, expected)
+
+    def test_whitespaces(self):
+        actual = calculate(['  ', '\t ', '\n\n'])
+        expected = {}
+        self.assertDictEqual(actual, expected)
+
+    def test_repeated_string_with_known_frequencies(self):
+        letter_frequency = 3
+        text_input = 'abc\n' * letter_frequency
+        actual = calculate(text_input.split('\n'))
+        expected = {'a': letter_frequency, 'b': letter_frequency,
+                    'c': letter_frequency}
+        self.assertDictEqual(actual, expected)
+
+    def test_multiline_text(self):
+        text_input = "3 Quotes from Excerism Homepage:\n" + \
+                     "\tOne moment you feel like you're\n" + \
+                     "getting it. The next moment you're\n" + \
+                     "stuck.\n" + \
+                     "\tYou know what it’s like to be fluent.\n" + \
+                     "Suddenly you’re feeling incompetent\n" + \
+                     "and clumsy.\n" + \
+                     "\tHaphazard, convoluted code is\n" + \
+                     "infuriating, not to mention costly. That\n" + \
+                     "slapdash explosion of complexity is an\n" + \
+                     "expensive yak shave waiting to\n" + \
+                     "happen."
+        actual = calculate(text_input.split('\n'))
+        expected = Counter([x for x in text_input.lower() if x.isalpha()])
+        self.assertDictEqual(actual, expected)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/python/exercises/reverse-string/reverse_string_test.py

@@ -6,19 +6,19 @@ from reverse_string import reverse
 # Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.1
 
 class ReverseStringTests(unittest.TestCase):
-    def empty_string(self):
+    def test_empty_string(self):
             self.assertEqual(reverse(''), '')
 
-    def a_word(self):
+    def test_a_word(self):
             self.assertEqual(reverse('robot'), 'tobor')
 
-    def a_capitalized_word(self):
+    def test_a_capitalized_word(self):
             self.assertEqual(reverse('Ramen'), 'nemaR')
 
-    def a_sentence_with_punctuation(self):
+    def test_a_sentence_with_punctuation(self):
             self.assertEqual(reverse('I\'m hungry!'), '!yrgnuh m\'I')
 
-    def a_palindrome(self):
+    def test_a_palindrome(self):
             self.assertEqual(reverse('racecar'), 'racecar')
 
 

data/tracks/ruby/README.md

@@ -315,9 +315,15 @@ string indices to integer indices.
 
 ## READMEs
 
-Do not add a README or README.md file to the exercise's directory. The READMEs
+All exercises must have a README.md file, but should not be created manually. The READMEs
 are constructed using shared metadata, which lives in the [problem-specifications][] repo.
 
+Use the `configlet` tool to generate a README from shared metadata:
+
+1. Clone the [problem-specifications][] repo into an adjacent directory.
+2. Fetch the configlet appropriate for your system: `bin/fetch-configlet`
+3. Generate the readme for a particular exercise: `bin/configlet generate . --only rotational-cipher`
+
 ## Contributing Guide
 
 For an in-depth discussion of how exercism language tracks and exercises work, please see the

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

@@ -0,0 +1,63 @@
+# 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.`
+
+* * * *
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/ruby).
+
+For running the tests provided, you will need the Minitest gem. Open a
+terminal window and run the following command to install minitest:
+
+    gem install minitest
+
+If you would like color output, you can `require 'minitest/pride'` in
+the test file, or note the alternative instruction, below, for running
+the test file.
+
+In order to run the test, you can run the test file from the exercise
+directory. For example, if the test suite is called
+`hello_world_test.rb`, you can run the following command:
+
+    ruby hello_world_test.rb
+
+To include color from the command line:
+
+    ruby -r minitest/pride hello_world_test.rb
+
+
+## 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.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.2.1.83
+  version: 2.2.1.84
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-02 00:00:00.000000000 Z
+date: 2018-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -621,6 +621,9 @@ files:
 - tracks/bash/exercises/bob/README.md
 - tracks/bash/exercises/bob/bob_test.sh
 - tracks/bash/exercises/bob/example.sh
+- tracks/bash/exercises/collatz-conjecture/README.md
+- tracks/bash/exercises/collatz-conjecture/collatz_test.sh
+- tracks/bash/exercises/collatz-conjecture/example.sh
 - tracks/bash/exercises/difference-of-squares/README.md
 - tracks/bash/exercises/difference-of-squares/difference_of_squares_test.sh
 - tracks/bash/exercises/difference-of-squares/example.sh
@@ -631,6 +634,9 @@ files:
 - tracks/bash/exercises/gigasecond/README.md
 - tracks/bash/exercises/gigasecond/example.sh
 - tracks/bash/exercises/gigasecond/gigasecond_test.sh
+- tracks/bash/exercises/grains/README.md
+- tracks/bash/exercises/grains/example.sh
+- tracks/bash/exercises/grains/grains_test.sh
 - tracks/bash/exercises/hamming/README.md
 - tracks/bash/exercises/hamming/example.sh
 - tracks/bash/exercises/hamming/hamming_test.sh
@@ -641,6 +647,9 @@ files:
 - tracks/bash/exercises/leap/README.md
 - tracks/bash/exercises/leap/example.sh
 - tracks/bash/exercises/leap/leap_test.sh
+- tracks/bash/exercises/luhn/README.md
+- tracks/bash/exercises/luhn/example.sh
+- tracks/bash/exercises/luhn/luhn_test.sh
 - tracks/bash/exercises/nucleotide-count/README.md
 - tracks/bash/exercises/nucleotide-count/example.sh
 - tracks/bash/exercises/nucleotide-count/nucleotide_count_test.sh
@@ -1715,6 +1724,11 @@ files:
 - tracks/clojure/exercises/trinary/project.clj
 - tracks/clojure/exercises/trinary/src/example.clj
 - tracks/clojure/exercises/trinary/test/trinary_test.clj
+- tracks/clojure/exercises/two-fer/README.md
+- tracks/clojure/exercises/two-fer/project.clj
+- tracks/clojure/exercises/two-fer/src/example.clj
+- tracks/clojure/exercises/two-fer/src/two_fer.clj
+- tracks/clojure/exercises/two-fer/test/two_fer_test.clj
 - tracks/clojure/exercises/word-count/README.md
 - tracks/clojure/exercises/word-count/project.clj
 - tracks/clojure/exercises/word-count/src/example.clj
@@ -11085,6 +11099,10 @@ files:
 - tracks/python/exercises/pangram/example.py
 - tracks/python/exercises/pangram/pangram.py
 - tracks/python/exercises/pangram/pangram_test.py
+- tracks/python/exercises/parallel-letter-frequency/README.md
+- tracks/python/exercises/parallel-letter-frequency/example.py
+- tracks/python/exercises/parallel-letter-frequency/parallel_letter_frequency.py
+- tracks/python/exercises/parallel-letter-frequency/parallel_letter_frequency_test.py
 - tracks/python/exercises/pascals-triangle/README.md
 - tracks/python/exercises/pascals-triangle/example.py
 - tracks/python/exercises/pascals-triangle/pascals_triangle.py
@@ -11882,6 +11900,7 @@ files:
 - tracks/ruby/exercises/rotational-cipher/.meta/.version
 - tracks/ruby/exercises/rotational-cipher/.meta/generator/rotational_cipher_case.rb
 - tracks/ruby/exercises/rotational-cipher/.meta/solutions/rotational_cipher.rb
+- tracks/ruby/exercises/rotational-cipher/README.md
 - tracks/ruby/exercises/rotational-cipher/rotational_cipher_test.rb
 - tracks/ruby/exercises/run-length-encoding/.meta/.version
 - tracks/ruby/exercises/run-length-encoding/.meta/generator/run_length_encoding_case.rb