Merge pull request #979 from petertseng/readme

README updates from problem-specifications

Author: petertseng

exercises/affine-cipher/README.md

@@ -2,43 +2,43 @@
 
 Create an implementation of the affine cipher,
 an ancient encryption system created in the Middle East.
- 
+
 The affine cipher is a type of monoalphabetic substitution cipher.
 Each character is mapped to its numeric equivalent, encrypted with
 a mathematical function and then converted to the letter relating to
 its new numeric value. Although all monoalphabetic ciphers are weak,
 the affine cypher is much stronger than the atbash cipher,
 because it has many more keys.
- 
+
 the encryption function is:
- 
+
   `E(x) = (ax + b) mod m`
   -  where `x` is the letter's index from 0 - length of alphabet - 1
   -  `m` is the length of the alphabet. For the roman alphabet `m == 26`.
   -  and `a` and `b` make the key
- 
+
 the decryption function is:
- 
+
   `D(y) = a^-1(y - b) mod m`
   -  where `y` is the numeric value of an encrypted letter, ie. `y = E(x)`
   -  it is important to note that `a^-1` is the modular multiplicative inverse
      of `a mod m`
   -  the modular multiplicative inverse of `a` only exists if `a` and `m` are
      coprime.
- 
+
 To find the MMI of `a`:
 
   `an mod m = 1`
   -  where `n` is the modular multiplicative inverse of `a mod m`
 
 More information regarding how to find a Modular Multiplicative Inverse
-and what it means can be found [here.](https://en.wikipedia.org/wiki/Modular_multiplicative_inverse) 
+and what it means can be found [here.](https://en.wikipedia.org/wiki/Modular_multiplicative_inverse)
 
 Because automatic decryption fails if `a` is not coprime to `m` your
 program should return status 1 and `"Error: a and m must be coprime."`
 if they are not.  Otherwise it should encode or decode with the
 provided key.
- 
+
 The Caesar (shift) cipher is a simple affine cipher where `a` is 1 and
 `b` as the magnitude results in a static displacement of the letters.
 This is much less secure than a full implementation of the affine cipher.
@@ -48,7 +48,7 @@ size being 5 letters, and punctuation is excluded. This is to make it
 harder to guess things based on word boundaries.
 
 ## Examples
- 
+
  - Encoding `test` gives `ybty` with the key a=5 b=7
  - Decoding `ybty` gives `test` with the key a=5 b=7
  - Decoding `ybty` gives `lqul` with the wrong key a=11 b=7

exercises/grade-school/README.md

@@ -15,8 +15,11 @@ In the end, you should be able to:
   as 1, 2, 3, etc., and students within a grade should be sorted
   alphabetically by name.
   - "Who all is enrolled in school right now?"
-  - "Grade 1: Anna, Barb, and Charlie. Grade 2: Alex, Peter, and Zoe.
-    Grade 3…"
+  - "Let me think. We have
+  Anna, Barb, and Charlie in grade 1,
+  Alex, Peter, and Zoe in grade 2
+  and Jim in grade 5.
+  So the answer is: Anna, Barb, Charlie, Alex, Peter, Zoe and Jim"
 
 Note that all our students only have one name.  (It's a small town, what
 do you want?)

exercises/isbn-verifier/README.md

@@ -40,6 +40,7 @@ Now, it's even trickier since the check digit of an ISBN-10 may be 'X' (represen
 * Generate a valid ISBN-13 from the input ISBN-10 (and maybe verify it again with a derived verifier).
 
 * Generate valid ISBN, maybe even from a given starting ISBN.
+
 ## Rust Installation
 
 Refer to the [exercism help page][help-page] for Rust installation and learning

exercises/luhn/README.md

@@ -19,27 +19,27 @@ are disallowed.
 ## Example 1: valid credit card number
 
 ```text
-4539 1488 0343 6467
+4539 3195 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_
+4_3_ 3_9_ 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
+8569 6195 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
+8+5+6+9+6+1+9+5+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!

exercises/minesweeper/README.md

@@ -10,7 +10,7 @@ In this exercise you have to create some code that counts the number of
 mines adjacent to a given empty square and replaces that square with the
 count.
 
-The board is a rectangle composed of blank space (' ') characters. A mine 
+The board is a rectangle composed of blank space (' ') characters. A mine
 is represented by an asterisk ('\*') character.
 
 If a given space has no adjacent mines at all, leave that square blank.

exercises/palindrome-products/README.md

@@ -6,7 +6,7 @@ A palindromic number is a number that remains the same when its digits are
 reversed. For example, `121` is a palindromic number but `112` is not.
 
 Given a range of numbers, find the largest and smallest palindromes which
-are products of numbers within that range.
+are products of two numbers within that range.
 
 Your solution should return the largest and smallest palindromes, along with the
 factors of each within the range. If the largest or smallest palindrome has more

exercises/robot-name/README.md

@@ -90,7 +90,7 @@ If you want to know more about Exercism, take a look at the [contribution guide]
 
 ## Source
 
-A debugging session with Paul Blackwell at gSchool. [http://gschool.it](http://gschool.it)
+A debugging session with Paul Blackwell at gSchool.
 
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/scale-generator/README.md

@@ -43,10 +43,10 @@ a "whole step" or "major second" (written as an upper-case "M"). The
 diatonic scales are built using only these two intervals between
 adjacent notes.
 
-Non-diatonic scales can contain other intervals.  An "augmented first"
-interval, written "A", has two interceding notes (e.g., from A to C or
-Db to E). There are also smaller and larger intervals, but they will not
-figure into this exercise.
+Non-diatonic scales can contain other intervals.  An "augmented second"
+interval, written "A", has two interceding notes (e.g., from A to C or Db to E)
+or a "whole step" plus a "half step". There are also smaller and larger
+intervals, but they will not figure into this exercise.
 
 ## Rust Installation
 

exercises/simple-cipher/README.md

@@ -61,7 +61,7 @@ substitution cipher a little more fault tolerant by providing a source
 of randomness and ensuring that the key contains only lowercase letters.
 
 If someone doesn't submit a key at all, generate a truly random key of
-at least 100 alphanumeric characters in length.
+at least 100 lowercase characters in length.
 
 ## Extensions
 

exercises/simple-linked-list/README.md

@@ -131,7 +131,7 @@ If you want to know more about Exercism, take a look at the [contribution guide]
 
 ## Source
 
-Inspired by 'Data Structures and Algorithms with Object-Oriented Design Patterns in Ruby', singly linked-lists. [https://web.archive.org/web/20160414064110/http://www.brpreiss.com/books/opus8/](https://web.archive.org/web/20160414064110/http://www.brpreiss.com/books/opus8/)
+Inspired by 'Data Structures and Algorithms with Object-Oriented Design Patterns in Ruby', singly linked-lists. [https://web.archive.org/web/20160731005714/http://brpreiss.com/books/opus8/html/page96.html](https://web.archive.org/web/20160731005714/http://brpreiss.com/books/opus8/html/page96.html)
 
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.