chore: Sync exercise documentation via configlet

exercises/practice/anagram/.docs/instructions.md

@@ -1,13 +1,12 @@
 # Instructions
 
-Your task is to, given a target word and a set of candidate words, to find the subset of the candidates that are anagrams of the target.
+Given a target word and one or more candidate words, your task is to find the candidates that are anagrams of the target.
 
 An anagram is a rearrangement of letters to form a new word: for example `"owns"` is an anagram of `"snow"`.
 A word is _not_ its own anagram: for example, `"stop"` is not an anagram of `"stop"`.
 
-The target and candidates are words of one or more ASCII alphabetic characters (`A`-`Z` and `a`-`z`).
-Lowercase and uppercase characters are equivalent: for example, `"PoTS"` is an anagram of `"sTOp"`, but `StoP` is not an anagram of `sTOp`.
-The anagram set is the subset of the candidate set that are anagrams of the target (in any order).
-Words in the anagram set should have the same letter case as in the candidate set.
+The target word and candidate words are made up of one or more ASCII alphabetic characters (`A`-`Z` and `a`-`z`).
+Lowercase and uppercase characters are equivalent: for example, `"PoTS"` is an anagram of `"sTOp"`, but `"StoP"` is not an anagram of `"sTOp"`.
+The words you need to find should be taken from the candidate words, using the same letter case.
 
-Given the target `"stone"` and candidates `"stone"`, `"tones"`, `"banana"`, `"tons"`, `"notes"`, `"Seton"`, the anagram set is `"tones"`, `"notes"`, `"Seton"`.
+Given the target `"stone"` and the candidate words `"stone"`, `"tones"`, `"banana"`, `"tons"`, `"notes"`, and `"Seton"`, the anagram words you need to find are `"tones"`, `"notes"`, and `"Seton"`.

exercises/practice/atbash-cipher/.docs/instructions.md

@@ -1,6 +1,6 @@
 # Instructions
 
-Create an implementation of the atbash cipher, an ancient encryption system created in the Middle East.
+Create an implementation of the Atbash cipher, an ancient encryption system created in the Middle East.
 
 The Atbash cipher is a simple substitution cipher that relies on transposing all the letters in the alphabet such that the resulting alphabet is backwards.
 The first letter is replaced with the last letter, the second with the second-last, and so on.

exercises/practice/change/.docs/instructions.md

@@ -1,14 +1,8 @@
 # Instructions
 
-Correctly determine the fewest number of coins to be given to a customer such that the sum of the coins' value would equal the correct amount of change.
+Determine the fewest number of coins to give a customer so that the sum of their values equals the correct amount of change.
 
-## For example
+## Examples
 
-- An input of 15 with [1, 5, 10, 25, 100] should return one nickel (5) and one dime (10) or [5, 10]
-- An input of 40 with [1, 5, 10, 25, 100] should return one nickel (5) and one dime (10) and one quarter (25) or [5, 10, 25]
-
-## Edge cases
-
-- Does your algorithm work for any given set of coins?
-- Can you ask for negative change?
-- Can you ask for a change value smaller than the smallest coin value?
+- An amount of 15 with available coin values [1, 5, 10, 25, 100] should return one coin of value 5 and one coin of value 10, or [5, 10].
+- An amount of 40 with available coin values [1, 5, 10, 25, 100] should return one coin of value 5, one coin of value 10, and one coin of value 25, or [5, 10, 25].

exercises/practice/collatz-conjecture/.docs/instructions.md

@@ -1,29 +1,3 @@
 # Instructions
 
-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.
+Given a positive integer, return the number of steps it takes to reach 1 according to the rules of the Collatz Conjecture.

exercises/practice/complex-numbers/.docs/instructions.md

@@ -1,29 +1,100 @@
 # Instructions
 
-A complex number is a number in the form `a + b * i` where `a` and `b` are real and `i` satisfies `i^2 = -1`.
+A **complex number** is expressed in the form `z = a + b * i`, where:
 
-`a` is called the real part and `b` is called the imaginary part of `z`.
-The conjugate of the number `a + b * i` is the number `a - b * i`.
-The absolute value of a complex number `z = a + b * i` is a real number `|z| = sqrt(a^2 + b^2)`. The square of the absolute value `|z|^2` is the result of multiplication of `z` by its complex conjugate.
+- `a` is the **real part** (a real number),
 
-The sum/difference of two complex numbers involves adding/subtracting their real and imaginary parts separately:
-`(a + i * b) + (c + i * d) = (a + c) + (b + d) * i`,
-`(a + i * b) - (c + i * d) = (a - c) + (b - d) * i`.
+- `b` is the **imaginary part** (also a real number), and
 
-Multiplication result is by definition
-`(a + i * b) * (c + i * d) = (a * c - b * d) + (b * c + a * d) * i`.
+- `i` is the **imaginary unit** satisfying `i^2 = -1`.
 
-The reciprocal of a non-zero complex number is
-`1 / (a + i * b) = a/(a^2 + b^2) - b/(a^2 + b^2) * i`.
+## Operations on Complex Numbers
 
-Dividing a complex number `a + i * b` by another `c + i * d` gives:
-`(a + i * b) / (c + i * d) = (a * c + b * d)/(c^2 + d^2) + (b * c - a * d)/(c^2 + d^2) * i`.
+### Conjugate
 
-Raising e to a complex exponent can be expressed as `e^(a + i * b) = e^a * e^(i * b)`, the last term of which is given by Euler's formula `e^(i * b) = cos(b) + i * sin(b)`.
+The conjugate of the complex number `z = a + b * i` is given by:
 
-Implement the following operations:
+```text
+zc = a - b * i
+```
 
-- addition, subtraction, multiplication and division of two complex numbers,
-- conjugate, absolute value, exponent of a given complex number.
+### Absolute Value
 
-Assume the programming language you are using does not have an implementation of complex numbers.
+The absolute value (or modulus) of `z` is defined as:
+
+```text
+|z| = sqrt(a^2 + b^2)
+```
+
+The square of the absolute value is computed as the product of `z` and its conjugate `zc`:
+
+```text
+|z|^2 = z * zc = a^2 + b^2
+```
+
+### Addition
+
+The sum of two complex numbers `z1 = a + b * i` and `z2 = c + d * i` is computed by adding their real and imaginary parts separately:
+
+```text
+z1 + z2 = (a + b * i) + (c + d * i)
+        = (a + c) + (b + d) * i
+```
+
+### Subtraction
+
+The difference of two complex numbers is obtained by subtracting their respective parts:
+
+```text
+z1 - z2 = (a + b * i) - (c + d * i)
+        = (a - c) + (b - d) * i
+```
+
+### Multiplication
+
+The product of two complex numbers is defined as:
+
+```text
+z1 * z2 = (a + b * i) * (c + d * i)
+        = (a * c - b * d) + (b * c + a * d) * i
+```
+
+### Reciprocal
+
+The reciprocal of a non-zero complex number is given by:
+
+```text
+1 / z = 1 / (a + b * i)
+      = a / (a^2 + b^2) - b / (a^2 + b^2) * i
+```
+
+### Division
+
+The division of one complex number by another is given by:
+
+```text
+z1 / z2 = z1 * (1 / z2)
+        = (a + b * i) / (c + d * i)
+        = (a * c + b * d) / (c^2 + d^2) + (b * c - a * d) / (c^2 + d^2) * i
+```
+
+### Exponentiation
+
+Raising _e_ (the base of the natural logarithm) to a complex exponent can be expressed using Euler's formula:
+
+```text
+e^(a + b * i) = e^a * e^(b * i)
+              = e^a * (cos(b) + i * sin(b))
+```
+
+## Implementation Requirements
+
+Given that you should not use built-in support for complex numbers, implement the following operations:
+
+- **addition** of two complex numbers
+- **subtraction** of two complex numbers
+- **multiplication** of two complex numbers
+- **division** of two complex numbers
+- **conjugate** of a complex number
+- **absolute value** of a complex number
+- **exponentiation** of _e_ (the base of the natural logarithm) to a complex number

exercises/practice/dominoes/.docs/instructions.md

@@ -2,7 +2,9 @@
 
 Make a chain of dominoes.
 
-Compute a way to order a given set of dominoes in such a way that they form a correct domino chain (the dots on one half of a stone match the dots on the neighboring half of an adjacent stone) and that dots on the halves of the stones which don't have a neighbor (the first and last stone) match each other.
+Compute a way to order a given set of domino stones so that they form a correct domino chain.
+In the chain, the dots on one half of a stone must match the dots on the neighboring half of an adjacent stone.
+Additionally, the dots on the halves of the stones without neighbors (the first and last stone) must match each other.
 
 For example given the stones `[2|1]`, `[2|3]` and `[1|3]` you should compute something
 like `[1|2] [2|3] [3|1]` or `[3|2] [2|1] [1|3]` or `[1|3] [3|2] [2|1]` etc, where the first and last numbers are the same.

exercises/practice/flatten-array/.docs/instructions.md

@@ -1,11 +1,16 @@
 # Instructions
 
-Take a nested list and return a single flattened list with all values except nil/null.
+Take a nested array of any depth and return a fully flattened array.
 
-The challenge is to take an arbitrarily-deep nested list-like structure and produce a flattened structure without any nil/null values.
+Note that some language tracks may include null-like values in the input array, and the way these values are represented varies by track.
+Such values should be excluded from the flattened array.
 
-For example:
+Additionally, the input may be of a different data type and contain different types, depending on the track.
 
-input: [1,[2,3,null,4],[null],5]
+Check the test suite for details.
 
-output: [1,2,3,4,5]
+## Example
+
+input: `[1, [2, 6, null], [[null, [4]], 5]]`
+
+output: `[1, 2, 6, 4, 5]`

exercises/practice/grade-school/.docs/instructions.md

@@ -1,21 +1,21 @@
 # Instructions
 
-Given students' names along with the grade that they are in, create a roster for the school.
+Given students' names along with the grade they are in, create a roster for the school.
 
 In the end, you should be able to:
 
-- Add a student's name to the roster for a grade
+- Add a student's name to the roster for a grade:
   - "Add Jim to grade 2."
   - "OK."
-- Get a list of all students enrolled in a grade
+- Get a list of all students enrolled in a grade:
   - "Which students are in grade 2?"
-  - "We've only got Jim just now."
+  - "We've only got Jim right now."
 - Get a sorted list of all students in all grades.
-  Grades should sort as 1, 2, 3, etc., and students within a grade should be sorted alphabetically by name.
-  - "Who all is enrolled in school right now?"
+  Grades should be sorted as 1, 2, 3, etc., and students within a grade should be sorted alphabetically by name.
+  - "Who is enrolled in school right now?"
   - "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"
+    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?) and each student cannot be added more than once to a grade or the roster.
-In fact, when a test attempts to add the same student more than once, your implementation should indicate that this is incorrect.
+Note that all our students only have one name (it's a small town, what do you want?), and each student cannot be added more than once to a grade or the roster.
+If a test attempts to add the same student more than once, your implementation should indicate that this is incorrect.

exercises/practice/grains/.docs/instructions.md

@@ -1,15 +1,11 @@
 # Instructions
 
-Calculate the number of grains of wheat on a chessboard given that the number on each square doubles.
+Calculate the number of grains of wheat on a chessboard.
 
-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, with the number of grains doubling on each successive square.
+A chessboard has 64 squares.
+Square 1 has one grain, square 2 has two grains, square 3 has four grains, and so on, doubling each time.
 
-There are 64 squares on a chessboard (where square 1 has one grain, square 2 has two grains, and so on).
+Write code that calculates:
 
-Write code that shows:
-
-- how many grains were on a given square, and
+- the number of grains on a given square
 - the total number of grains on the chessboard

exercises/practice/hamming/.docs/instructions.md

@@ -2,15 +2,6 @@
 
 Calculate the Hamming distance between two DNA strands.
 
-Your body is made up of cells that contain DNA.
-Those cells regularly wear out and need replacing, which they achieve by dividing into daughter cells.
-In fact, the average human body experiences about 10 quadrillion cell divisions in a lifetime!
-
-When cells divide, their DNA replicates too.
-Sometimes during this process mistakes happen and single pieces of DNA get encoded with the incorrect information.
-If we compare two strands of DNA and count the differences between them we can see how many mistakes occurred.
-This is known as the "Hamming distance".
-
 We read DNA using the letters C, A, G and T.
 Two strands might look like this:
 
@@ -20,8 +11,6 @@ Two strands might look like this:
 
 They have 7 differences, and therefore the Hamming distance is 7.
 
-The Hamming distance is useful for lots of things in science, not just biology, so it's a nice phrase to be familiar with :)
-
 ## Implementation notes
 
 The Hamming distance is only defined for sequences of equal length, so an attempt to calculate it between sequences of different lengths should not work.

exercises/practice/luhn/.docs/instructions.md

@@ -1,65 +1,68 @@
 # Instructions
 
-Given a number determine whether or not it is valid per the Luhn formula.
+Determine whether a number is valid according to the [Luhn formula][luhn].
 
-The [Luhn algorithm][luhn] is a simple checksum formula used to validate a variety of identification numbers, such as credit card numbers and Canadian Social Insurance Numbers.
+The number will be provided as a string.
 
-The task is to check if a given string is valid.
-
-## Validating a Number
+## 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
+## Examples
 
-```text
-4539 3195 0343 6467
-```
+### Valid credit card number
 
-The first step of the Luhn algorithm is to double every second digit, starting from the right.
-We will be doubling
+The number to be checked is `4539 3195 0343 6467`.
+
+The first step of the Luhn algorithm is to start at the end of the number and double every second digit, beginning with the second digit from the right and moving left.
 
 ```text
 4539 3195 0343 6467
 ↑ ↑  ↑ ↑  ↑ ↑  ↑ ↑  (double these)
 ```
 
-If doubling the number results in a number greater than 9 then subtract 9 from the product.
-The results of our doubling:
+If the result of doubling a digit is greater than 9, we subtract 9 from that result.
+We end up with:
 
 ```text
 8569 6195 0383 3437
 ```
 
-Then sum all of the digits:
+Finally, we sum all digits.
+If the sum is evenly divisible by 10, the original number is valid.
 
 ```text
-8+5+6+9+6+1+9+5+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!
+80 is evenly divisible by 10, so number `4539 3195 0343 6467` is valid!
+
+### Invalid Canadian SIN
+
+The number to be checked is `066 123 468`.
 
-### Example 2: invalid credit card number
+We start at the end of the number and double every second digit, beginning with the second digit from the right and moving left.
 
 ```text
-8273 1232 7352 0569
+066 123 478
+ ↑  ↑ ↑  ↑  (double these)
 ```
 
-Double the second digits, starting from the right
+If the result of doubling a digit is greater than 9, we subtract 9 from that result.
+We end up with:
 
 ```text
-7253 2262 5312 0539
+036 226 458
 ```
 
-Sum the digits
+We sum the digits:
 
 ```text
-7+2+5+3+2+2+6+2+5+3+1+2+0+5+3+9 = 57
+0 + 3 + 6 + 2 + 2 + 6 + 4 + 5 + 8 = 36
 ```
 
-57 is not evenly divisible by 10, so this number is not valid.
+36 is not evenly divisible by 10, so number `066 123 478` is not valid!
 
 [luhn]: https://en.wikipedia.org/wiki/Luhn_algorithm