🤖 Auto-sync docs, metadata, and filepaths (#999)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Author: github-actions[bot]

exercises/practice/binary-search-tree/.docs/instructions.md

@@ -19,29 +19,52 @@ All data in the left subtree is less than or equal to the current node's data, a
 
 For example, if we had a node containing the data 4, and we added the data 2, our tree would look like this:
 
+![A graph with root node 4 and a single child node 2.](https://assets.exercism.org/images/exercises/binary-search-tree/tree-4-2.svg)
+
+```text
       4
      /
     2
+```
 
 If we then added 6, it would look like this:
 
+![A graph with root node 4 and two child nodes 2 and 6.](https://assets.exercism.org/images/exercises/binary-search-tree/tree-4-2-6.svg)
+
+```text
       4
      / \
     2   6
+```
 
 If we then added 3, it would look like this
 
+![A graph with root node 4, two child nodes 2 and 6, and a grandchild node 3.](https://assets.exercism.org/images/exercises/binary-search-tree/tree-4-2-6-3.svg)
+
+```text
        4
      /   \
     2     6
      \
       3
+```
 
 And if we then added 1, 5, and 7, it would look like this
 
+![A graph with root node 4, two child nodes 2 and 6, and four grandchild nodes 1, 3, 5 and 7.](https://assets.exercism.org/images/exercises/binary-search-tree/tree-4-2-6-1-3-5-7.svg)
+
+```text
           4
         /   \
        /     \
       2       6
      / \     / \
     1   3   5   7
+```
+
+## Credit
+
+The images were created by [habere-et-dispertire][habere-et-dispertire] using [PGF/TikZ][pgf-tikz] by Till Tantau.
+
+[habere-et-dispertire]: https://exercism.org/profiles/habere-et-dispertire
+[pgf-tikz]: https://en.wikipedia.org/wiki/PGF/TikZ

exercises/practice/eliuds-eggs/.docs/introduction.md

@@ -58,7 +58,7 @@ The position information encoding is calculated as follows:
 
 ### Decimal number on the display
 
-16
+8
 
 ### Actual eggs in the coop
 

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

@@ -1,6 +1,6 @@
 # Instructions
 
-Determine whether a credit card number is valid according to the [Luhn formula][luhn].
+Determine whether a number is valid according to the [Luhn formula][luhn].
 
 The number will be provided as a string.
 
@@ -10,54 +10,59 @@ 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 478`.
 
-### 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

exercises/practice/luhn/.docs/introduction.md

@@ -2,10 +2,10 @@
 
 At the Global Verification Authority, you've just been entrusted with a critical assignment.
 Across the city, from online purchases to secure logins, countless operations rely on the accuracy of numerical identifiers like credit card numbers, bank account numbers, transaction codes, and tracking IDs.
-The Luhn algorithm is a simple checksum formula used to ensure these numbers are valid and error-free.
+The Luhn algorithm is a simple checksum formula used to help identify mistyped numbers.
 
 A batch of identifiers has just arrived on your desk.
 All of them must pass the Luhn test to ensure they're legitimate.
-If any fail, they'll be flagged as invalid, preventing errors or fraud, such as incorrect transactions or unauthorized access.
+If any fail, they'll be flagged as invalid, preventing mistakes such as incorrect transactions or failed account verifications.
 
 Can you ensure this is done right? The integrity of many services depends on you.

exercises/practice/meetup/.docs/instructions.md

@@ -2,7 +2,7 @@
 
 Your task is to find the exact date of a meetup, given a month, year, weekday and week.
 
-There are five week values to consider: `first`, `second`, `third`, `fourth`, `last`, `teenth`.
+There are six week values to consider: `first`, `second`, `third`, `fourth`, `last`, `teenth`.
 
 For example, you might be asked to find the date for the meetup on the first Monday in January 2018 (January 1, 2018).
 

exercises/practice/phone-number/.docs/instructions.md

@@ -1,6 +1,6 @@
 # Instructions
 
-Clean up user-entered phone numbers so that they can be sent SMS messages.
+Clean up phone numbers so that they can be sent SMS messages.
 
 The **North American Numbering Plan (NANP)** is a telephone numbering system used by many countries in North America like the United States, Canada or Bermuda.
 All NANP-countries share the same international country code: `1`.

exercises/practice/protein-translation/.docs/instructions.md

@@ -1,36 +1,17 @@
 # Instructions
 
-Translate RNA sequences into proteins.
+Your job is to translate RNA sequences into proteins.
 
-RNA can be broken into three-nucleotide sequences called codons, and then translated to a protein like so:
+RNA strands are made up of three-nucleotide sequences called **codons**.
+Each codon translates to an **amino acid**.
+When joined together, those amino acids make a protein.
 
-RNA: `"AUGUUUUCU"` => translates to
-
-Codons: `"AUG", "UUU", "UCU"`
-=> which become a protein with the following sequence =>
-
-Protein: `"Methionine", "Phenylalanine", "Serine"`
-
-There are 64 codons which in turn correspond to 20 amino acids; however, all of the codon sequences and resulting amino acids are not important in this exercise.
-If it works for one codon, the program should work for all of them.
-However, feel free to expand the list in the test suite to include them all.
-
-There are also three terminating codons (also known as 'STOP' codons); if any of these codons are encountered (by the ribosome), all translation ends and the protein is terminated.
-
-All subsequent codons after are ignored, like this:
-
-RNA: `"AUGUUUUCUUAAAUG"` =>
-
-Codons: `"AUG", "UUU", "UCU", "UAA", "AUG"` =>
-
-Protein: `"Methionine", "Phenylalanine", "Serine"`
-
-Note the stop codon `"UAA"` terminates the translation and the final methionine is not translated into the protein sequence.
-
-Below are the codons and resulting amino acids needed for the exercise.
+In the real world, there are 64 codons, which in turn correspond to 20 amino acids.
+However, for this exercise, you’ll only use a few of the possible 64.
+They are listed below:
 
 | Codon              | Amino Acid    |
-| :----------------- | :------------ |
+| ------------------ | ------------- |
 | AUG                | Methionine    |
 | UUU, UUC           | Phenylalanine |
 | UUA, UUG           | Leucine       |
@@ -40,6 +21,18 @@ Below are the codons and resulting amino acids needed for the exercise.
 | UGG                | Tryptophan    |
 | UAA, UAG, UGA      | STOP          |
 
+For example, the RNA string “AUGUUUUCU” has three codons: “AUG”, “UUU” and “UCU”.
+These map to Methionine, Phenylalanine, and Serine.
+
+## “STOP” Codons
+
+You’ll note from the table above that there are three **“STOP” codons**.
+If you encounter any of these codons, ignore the rest of the sequence — the protein is complete.
+
+For example, “AUGUUUUCUUAAAUG” contains a STOP codon (“UAA”).
+Once we reach that point, we stop processing.
+We therefore only consider the part before it (i.e. “AUGUUUUCU”), not any further codons after it (i.e. “AUG”).
+
 Learn more about [protein translation on Wikipedia][protein-translation].
 
 [protein-translation]: https://en.wikipedia.org/wiki/Translation_(biology)

exercises/practice/say/.docs/instructions.md

@@ -1,48 +1,12 @@
 # Instructions
 
-Given a number from 0 to 999,999,999,999, spell out that number in English.
+Given a number, your task is to express it in English words exactly as your friend should say it out loud.
+Yaʻqūb expects to use numbers from 0 up to 999,999,999,999.
 
-## Step 1
+Examples:
 
-Handle the basic case of 0 through 99.
-
-If the input to the program is `22`, then the output should be `'twenty-two'`.
-
-Your program should complain loudly if given a number outside the blessed range.
-
-Some good test cases for this program are:
-
-- 0
-- 14
-- 50
-- 98
-- -1
-- 100
-
-### Extension
-
-If you're on a Mac, shell out to Mac OS X's `say` program to talk out loud.
-If you're on Linux or Windows, eSpeakNG may be available with the command `espeak`.
-
-## Step 2
-
-Implement breaking a number up into chunks of thousands.
-
-So `1234567890` should yield a list like 1, 234, 567, and 890, while the far simpler `1000` should yield just 1 and 0.
-
-## Step 3
-
-Now handle inserting the appropriate scale word between those chunks.
-
-So `1234567890` should yield `'1 billion 234 million 567 thousand 890'`
-
-The program must also report any values that are out of range.
-It's fine to stop at "trillion".
-
-## Step 4
-
-Put it all together to get nothing but plain English.
-
-`12345` should give `twelve thousand three hundred forty-five`.
-
-The program must also report any values that are out of range.
+- 0 → zero
+- 1 → one
+- 12 → twelve
+- 123 → one hundred twenty-three
+- 1,234 → one thousand two hundred thirty-four

exercises/practice/say/.docs/introduction.md

@@ -0,0 +1,6 @@
+# Introduction
+
+Your friend Yaʻqūb works the counter at the busiest deli in town, slicing, weighing, and wrapping orders for a never-ending line of hungry customers.
+To keep things moving, each customer takes a numbered ticket when they arrive.
+
+When it’s time to call the next person, Yaʻqūb reads their number out loud, always in full English words to make sure everyone hears it clearly.

exercises/practice/triangle/.docs/instructions.md

@@ -13,6 +13,12 @@ A _scalene_ triangle has all sides of different lengths.
 
 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.
 
+~~~~exercism/note
+_Degenerate triangles_ are triangles where the sum of the length of two sides is **equal** to the length of the third side, e.g. `1, 1, 2`.
+We opted to not include tests for degenerate triangles in this exercise.
+You may handle those situations if you wish to do so, or safely ignore them.
+~~~~
+
 In equations:
 
 Let `a`, `b`, and `c` be sides of the triangle.