🤖 Configlet sync: docs, metadata, and filepaths (#2082)

Author: github-actions[bot]

exercises/practice/dot-dsl/.docs/instructions.md

@@ -22,7 +22,7 @@ Write a Domain Specific Language similar to the Graphviz dot language.
 Our DSL is similar to the Graphviz dot language in that our DSL will be used to create graph data structures.
 However, unlike the DOT Language, our DSL will be an internal DSL for use only in our language.
 
-More information about the difference between internal and external DSLs can be found [here][fowler-dsl].
+[Learn more about the difference between internal and external DSLs][fowler-dsl].
 
 [dsl]: https://en.wikipedia.org/wiki/Domain-specific_language
 [dot-language]: https://en.wikipedia.org/wiki/DOT_(graph_description_language)

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/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/simple-cipher/.docs/instructions.md

@@ -1,66 +1,40 @@
 # Instructions
 
-Implement a simple shift cipher like Caesar and a more secure substitution cipher.
+Create an implementation of the [Vigenère cipher][wiki].
+The Vigenère cipher is a simple substitution cipher.
 
-## Step 1
+## Cipher terminology
 
-"If he had anything confidential to say, he wrote it in cipher, that is, by so changing the order of the letters of the alphabet, that not a word could be made out.
-If anyone wishes to decipher these, and get at their meaning, he must substitute the fourth letter of the alphabet, namely D, for A, and so with the others."
-—Suetonius, Life of Julius Caesar
+A cipher is an algorithm used to encrypt, or encode, a string.
+The unencrypted string is called the _plaintext_ and the encrypted string is called the _ciphertext_.
+Converting plaintext to ciphertext is called _encoding_ while the reverse is called _decoding_.
 
-Ciphers are very straight-forward algorithms that allow us to render text less readable while still allowing easy deciphering.
-They are vulnerable to many forms of cryptanalysis, but Caesar was lucky that his enemies were not cryptanalysts.
+In a _substitution cipher_, each plaintext letter is replaced with a ciphertext letter which is computed with the help of a _key_.
+(Note, it is possible for replacement letter to be the same as the original letter.)
 
-The Caesar cipher was used for some messages from Julius Caesar that were sent afield.
-Now Caesar knew that the cipher wasn't very good, but he had one ally in that respect: almost nobody could read well.
-So even being a couple letters off was sufficient so that people couldn't recognize the few words that they did know.
+## Encoding details
 
-Your task is to create a simple shift cipher like the Caesar cipher.
-This image is a great example of the Caesar cipher:
+In this cipher, the key is a series of lowercase letters, such as `"abcd"`.
+Each letter of the plaintext is _shifted_ or _rotated_ by a distance based on a corresponding letter in the key.
+An `"a"` in the key means a shift of 0 (that is, no shift).
+A `"b"` in the key means a shift of 1.
+A `"c"` in the key means a shift of 2, and so on.
 
-![Caesar cipher][img-caesar-cipher]
+The first letter of the plaintext uses the first letter of the key, the second letter of the plaintext uses the second letter of the key and so on.
+If you run out of letters in the key before you run out of letters in the plaintext, start over from the start of the key again.
 
-For example:
+If the key only contains one letter, such as `"dddddd"`, then all letters of the plaintext are shifted by the same amount (three in this example), which would make this the same as a rotational cipher or shift cipher (sometimes called a Caesar cipher).
+For example, the plaintext `"iamapandabear"` would become `"ldpdsdqgdehdu"`.
 
-Giving "iamapandabear" as input to the encode function returns the cipher "ldpdsdqgdehdu".
-Obscure enough to keep our message secret in transit.
+If the key only contains the letter `"a"` (one or more times), the shift distance is zero and the ciphertext is the same as the plaintext.
 
-When "ldpdsdqgdehdu" is put into the decode function it would return the original "iamapandabear" letting your friend read your original message.
+Usually the key is more complicated than that, though!
+If the key is `"abcd"` then letters of the plaintext would be shifted by a distance of 0, 1, 2, and 3.
+If the plaintext is `"hello"`, we need 5 shifts so the key would wrap around, giving shift distances of 0, 1, 2, 3, and 0.
+Applying those shifts to the letters of `"hello"` we get `"hfnoo"`.
 
-## Step 2
+## Random keys
 
-Shift ciphers quickly cease to be useful when the opposition commander figures them out.
-So instead, let's try using a substitution cipher.
-Try amending the code to allow us to specify a key and use that for the shift distance.
+If no key is provided, generate a key which consists of at least 100 random lowercase letters from the Latin alphabet.
 
-Here's an example:
-
-Given the key "aaaaaaaaaaaaaaaaaa", encoding the string "iamapandabear"
-would return the original "iamapandabear".
-
-Given the key "ddddddddddddddddd", encoding our string "iamapandabear"
-would return the obscured "ldpdsdqgdehdu"
-
-In the example above, we've set a = 0 for the key value.
-So when the plaintext is added to the key, we end up with the same message coming out.
-So "aaaa" is not an ideal key.
-But if we set the key to "dddd", we would get the same thing as the Caesar cipher.
-
-## Step 3
-
-The weakest link in any cipher is the human being.
-Let's make your 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 lowercase characters in length.
-
-## Extensions
-
-Shift ciphers work by making the text slightly odd, but are vulnerable to frequency analysis.
-Substitution ciphers help that, but are still very vulnerable when the key is short or if spaces are preserved.
-Later on you'll see one solution to this problem in the exercise "crypto-square".
-
-If you want to go farther in this field, the questions begin to be about how we can exchange keys in a secure way.
-Take a look at [Diffie-Hellman on Wikipedia][dh] for one of the first implementations of this scheme.
-
-[img-caesar-cipher]: https://upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Caesar_cipher_left_shift_of_3.svg/320px-Caesar_cipher_left_shift_of_3.svg.png
-[dh]: https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange
+[wiki]: https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher

exercises/practice/simple-cipher/.meta/config.json

@@ -29,7 +29,7 @@
       ".meta/example.rs"
     ]
   },
-  "blurb": "Implement a simple shift cipher like Caesar and a more secure substitution cipher.",
+  "blurb": "Implement the Vigenère cipher, a simple substitution cipher.",
   "source": "Substitution Cipher at Wikipedia",
   "source_url": "https://en.wikipedia.org/wiki/Substitution_cipher"
 }