trackler 2.2.1.86 → 2.2.1.87

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

@@ -1,4 +1,4 @@
-# Collatz Conjecture 
+# Collatz Conjecture
 
 The Collatz Conjecture or 3x+1 problem can be summarized as follows:
 
@@ -26,9 +26,18 @@ Starting with n = 12, the steps would be as follows:
 
 Resulting in 9 steps. So for input n = 12, the return value would be 9.
 
+
+Run the tests with:
+
+```bash
+bats collatz_conjecture_test.sh
+```
+
+After the first test(s) pass, continue by commenting out or removing the `skip` annotations prepending other tests.
+
 ## Source
 
-An unsolved problem in mathematics named after mathematician Lothar Collatz [Wikipedia](https://en.wikipedia.org/wiki/3x_%2B_1_problem)
+An unsolved problem in mathematics named after mathematician Lothar Collatz [https://en.wikipedia.org/wiki/3x_%2B_1_problem](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 → collatz_conjecture_test.sh}

@@ -2,7 +2,7 @@
 
 @test "zero steps for one" {
   #skip
-  run bash collatz.sh 1
+  run bash collatz_conjecture.sh 1
 
   [ "$status" -eq 0 ]
   [ "$output" -eq 0 ]
@@ -10,7 +10,7 @@
 
 @test "divide if even" {
   skip
-  run bash collatz.sh 16
+  run bash collatz_conjecture.sh 16
 
   [ "$status" -eq 0 ]
   [ "$output" -eq 4 ]
@@ -18,7 +18,7 @@
 
 @test "even and odd steps" {
   skip
-  run bash collatz.sh 12
+  run bash collatz_conjecture.sh 12
 
   [ "$status" -eq 0 ]
   [ "$output" -eq 9 ]
@@ -26,7 +26,7 @@
 
 @test "large number of even and odd steps" {
   skip
-  run bash collatz.sh 1000000
+  run bash collatz_conjecture.sh 1000000
 
   [ "$status" -eq 0 ]
   [ "$output" -eq 152 ]
@@ -34,7 +34,7 @@
 
 @test "zero is an error" {
   skip
-  run bash collatz.sh 0
+  run bash collatz_conjecture.sh 0
 
   [ "$status" -eq 1 ]
   [ "$output" == "Error: Only positive numbers are allowed" ]
@@ -42,7 +42,7 @@
 
 @test "negative value is an error" {
   skip
-  run bash collatz.sh -15
+  run bash collatz_conjecture.sh -15
 
   [ "$status" -eq 1 ]
   [ "$output" == "Error: Only positive numbers are allowed" ]

data/tracks/bash/exercises/difference-of-squares/README.md

@@ -12,9 +12,14 @@ Hence the difference between the square of the sum of the first
 ten natural numbers and the sum of the squares of the first ten
 natural numbers is 3025 - 385 = 2640.
 
+
 Run the tests with:
 
-    bats difference_of_squares_test.sh
+```bash
+bats difference_of_squares_test.sh
+```
+
+After the first test(s) pass, continue by commenting out or removing the `skip` annotations prepending other tests.
 
 ## Source
 

data/tracks/bash/exercises/error-handling/README.md

@@ -1,15 +1,23 @@
-# Error-handling
+# Error Handling
 
 Implement various kinds of error handling and resource management.
 
-An important point of programming is how to handle errors and close resources even if errors occur.
+An important point of programming is how to handle errors and close
+resources even if errors occur.
+
+This exercise requires you to handle various errors. Because error handling
+is rather programming language specific you'll have to refer to the tests
+for your track to see what's exactly required.
 
-This exercise requires you to handle various errors. Because error handling is rather programming language specific you'll have to refer to the tests for your track to see what's exactly required.
 
 Run the tests with:
 
-    bats error_handling_test.sh
+```bash
+bats error_handling_test.sh
+```
+
+After the first test(s) pass, continue by commenting out or removing the `skip` annotations prepending other tests.
+
 
 ## 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/error-handling/error_handling_test.sh

@@ -1,36 +1,32 @@
 #!/usr/bin/env bats
 
 @test "correct arguments" {
-    #skip
-    run bash error_handling.sh Alice
-    
-    [ "$status" -eq 0 ]
-    [ "$output" = "Hello, Alice" ]
+  #skip
+  run bash error_handling.sh Alice
+
+  [ "$status" -eq 0 ]
+  [ "$output" = "Hello, Alice" ]
 }
 
 @test "one long argument" {
-    skip
-    run bash error_handling.sh "Alice and Bob"
-    
-    [ "$status" -eq 0 ]
-    [ "$output" = "Hello, Alice and Bob" ]
+  skip
+  run bash error_handling.sh "Alice and Bob"
+
+  [ "$status" -eq 0 ]
+  [ "$output" = "Hello, Alice and Bob" ]
 }
 
 @test "incorrect arguments" {
-    skip
-    run bash error_handling.sh Alice Bob
+  skip
+  run bash error_handling.sh Alice Bob
 
-    [ "$status" -ne 0 ]
+  [ "$status" -ne 0 ]
 }
 
-@test "use errexit" {
-    skip
-    source error_handling.sh
-    [ echo $SHELLOPTS | grep -q 'errexit' ]
-}
+@test "print usage banner with no value given" {
+  skip
+  run bash error_handling.sh
 
-@test "use nounset" {
-    skip
-    source error_handling.sh
-    [ echo $SHELLOPTS | grep -q 'nounset' ]
+  [ "$status" -eq 1 ]
+  [ "$output" = "Usage: ./error_handling <greetee>" ]
 }

data/tracks/bash/exercises/error-handling/example.sh

@@ -1,11 +1,12 @@
 #!/usr/bin/env bash
 
-set -eu
+set -o errexit
+set -o nounset
 
-if test $# -gt 1
-then
-    echo "Usage: hello <greetee>"
-    exit 1
+if [ $# -ne 1 ]; then
+  echo "Usage: ./error_handling <greetee>"
+  exit 1
 else
-    echo "Hello, ${1}"
+  echo "Hello, ${1}"
+  exit 0
 fi

data/tracks/bash/exercises/gigasecond/.meta/hints.md

@@ -26,8 +26,3 @@ 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.
-
-Run the tests with:
-
-    bats whatever_test.sh
-

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

@@ -4,9 +4,44 @@ Calculate the moment when someone has lived for 10^9 seconds.
 
 A gigasecond is 10^9 (1,000,000,000) seconds.
 
+## 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.
+
+
+
 Run the tests with:
 
-    bats gigasecond_test.sh
+```bash
+bats gigasecond_test.sh
+```
+
+After the first test(s) pass, continue by commenting out or removing the `skip` annotations prepending other tests.
 
 ## Source
 

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

@@ -26,10 +26,18 @@ are some additional things you could try:
 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?
 
+
+Run the tests with:
+
+```bash
+bats grains_test.sh
+```
+
+After the first test(s) pass, continue by commenting out or removing the `skip` annotations prepending other tests.
+
 ## 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) 
+JavaRanch Cattle Drive, exercise 6 [http://www.javaranch.com/grains.jsp](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/hamming/README.md

@@ -35,9 +35,14 @@ The Hamming distance is only defined for sequences of equal length. This means
 that based on the definition, each language could deal with getting sequences
 of equal length differently.
 
+
 Run the tests with:
 
-    bats hamming_test.sh
+```bash
+bats hamming_test.sh
+```
+
+After the first test(s) pass, continue by commenting out or removing the `skip` annotations prepending other tests.
 
 ## Source
 

data/tracks/bash/exercises/hello-world/README.md

@@ -29,7 +29,7 @@ can get the tests to pass on your machine, we are doing great.
 
 ## Installation
 
-As I said above, if you are on a unix-like OS (Mac OS X, Linux, Solaris,
+As mentioned above, if you are on a unix-like OS (Mac OS X, Linux, Solaris,
 etc), you probably already have bash.
 
 ## Testing
@@ -54,9 +54,14 @@ seconds
 ```
 
 
+
 Run the tests with:
 
-    bats hello_world_test.sh
+```bash
+bats hello_world_test.sh
+```
+
+After the first test(s) pass, continue by commenting out or removing the `skip` annotations prepending other tests.
 
 ## Source
 

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

@@ -4,7 +4,7 @@ Given a year, report if it is a leap year.
 
 The tricky thing here is that a leap year in the Gregorian calendar occurs:
 
-```plain
+```text
 on every year that is evenly divisible by 4
   except every year that is evenly divisible by 100
     unless the year is also evenly divisible by 400
@@ -26,9 +26,14 @@ phenomenon, go watch [this youtube video][video].
 
 [video]: http://www.youtube.com/watch?v=xX96xng7sAE
 
+
 Run the tests with:
 
-    bats leap_test.sh
+```bash
+bats leap_test.sh
+```
+
+After the first test(s) pass, continue by commenting out or removing the `skip` annotations prepending other tests.
 
 ## Source
 

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

@@ -64,13 +64,18 @@ Sum the digits
 
 57 is not evenly divisible by 10, so this number is not valid.
 
+
 Run the tests with:
 
-    bats luhn_test.sh
+```bash
+bats luhn_test.sh
+```
+
+After the first test(s) pass, continue by commenting out or removing the `skip` annotations prepending other tests.
 
 ## Source
 
-The Luhn Algorithm on Wikipedia [Wikipedia](http://en.wikipedia.org/wiki/Luhn_algorithm)
+The Luhn Algorithm on Wikipedia [http://en.wikipedia.org/wiki/Luhn_algorithm](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/nucleotide-count/README.md

@@ -1,34 +1,25 @@
 # Nucleotide Count
 
-Given a DNA string, compute how many times each nucleotide occurs in the string.
+Given a single stranded DNA string, compute how many times each nucleotide occurs in the string.
 
-DNA is represented by an alphabet of the following symbols: 'A', 'C',
-'G', and 'T'.
-
-Each symbol represents a nucleotide, which is a fancy name for the
-particular molecules that happen to make up a large part of DNA.
-
-Shortest intro to biochemistry EVAR:
+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:
 - twigs are to birds nests as
-- nucleotides are to DNA and RNA as
-- amino acids are to proteins as
-- sugar is to starch as
-- oh crap lipids
-
-I'm not going to talk about lipids because they're crazy complex.
+- nucleotides are to DNA as
+- legos are to lego houses as
+- words are to sentences as...
 
-So back to nucleotides.
-
-DNA contains four types of them: adenine (`A`), cytosine (`C`), guanine
-(`G`), and thymine (`T`).
-
-RNA contains a slightly different set of nucleotides, but we don't care
-about that for now.
 
 Run the tests with:
 
-    bats nucleotide_count_test.sh
+```bash
+bats nucleotide_count_test.sh
+```
+
+After the first test(s) pass, continue by commenting out or removing the `skip` annotations prepending other tests.
 
 ## Source
 

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

@@ -2,15 +2,20 @@
 
 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
 insensitive. Input will not contain non-ASCII symbols.
 
+
 Run the tests with:
 
-    bats pangram_test.sh
+```bash
+bats pangram_test.sh
+```
+
+After the first test(s) pass, continue by commenting out or removing the `skip` annotations prepending other tests.
 
 ## Source
 

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

@@ -6,14 +6,15 @@ 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.
+Your task is to clean up differently formatted telephone numbers by removing punctuation and the country code (1) if present.
 
 For example, the inputs
 - `+1 (613)-995-0253`
@@ -27,9 +28,14 @@ should all produce the output
 
 **Note:** As this exercise only deals with telephone numbers used in NANP-countries, only 1 is considered a valid country code.
 
+
 Run the tests with:
 
-    bats phone_number_test.sh
+```bash
+bats phone_number_test.sh
+```
+
+After the first test(s) pass, continue by commenting out or removing the `skip` annotations prepending other tests.
 
 ## Source