Sync docs and metadata (#253)

exercises/practice/hello-world/.meta/config.json

@@ -17,7 +17,7 @@
       ".meta/example.vim"
     ]
   },
-  "blurb": "The classical introductory exercise. Just say \"Hello, World!\".",
+  "blurb": "Exercism's classic introductory exercise. Just say \"Hello, World!\".",
   "source": "This is an exercise to introduce users to using Exercism",
   "source_url": "https://en.wikipedia.org/wiki/%22Hello,_world!%22_program"
 }

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

@@ -2,22 +2,38 @@
 
 Determine if a number is perfect, abundant, or deficient based on Nicomachus' (60 - 120 CE) classification scheme for positive integers.
 
-The Greek mathematician [Nicomachus][nicomachus] devised a classification scheme for positive integers, identifying each as belonging uniquely to the categories of **perfect**, **abundant**, or **deficient** based on their [aliquot sum][aliquot-sum].
-The aliquot sum is defined as the sum of the factors of a number not including the number itself.
+The Greek mathematician [Nicomachus][nicomachus] devised a classification scheme for positive integers, identifying each as belonging uniquely to the categories of [perfect](#perfect), [abundant](#abundant), or [deficient](#deficient) based on their [aliquot sum][aliquot-sum].
+The _aliquot sum_ is defined as the sum of the factors of a number not including the number itself.
 For example, the aliquot sum of `15` is `1 + 3 + 5 = 9`.
 
-- **Perfect**: aliquot sum = number
-  - 6 is a perfect number because (1 + 2 + 3) = 6
-  - 28 is a perfect number because (1 + 2 + 4 + 7 + 14) = 28
-- **Abundant**: aliquot sum > number
-  - 12 is an abundant number because (1 + 2 + 3 + 4 + 6) = 16
-  - 24 is an abundant number because (1 + 2 + 3 + 4 + 6 + 8 + 12) = 36
-- **Deficient**: aliquot sum < number
-  - 8 is a deficient number because (1 + 2 + 4) = 7
-  - Prime numbers are deficient
-
-Implement a way to determine whether a given number is **perfect**.
-Depending on your language track, you may also need to implement a way to determine whether a given number is **abundant** or **deficient**.
+## Perfect
+
+A number is perfect when it equals its aliquot sum.
+For example:
+
+- `6` is a perfect number because `1 + 2 + 3 = 6`
+- `28` is a perfect number because `1 + 2 + 4 + 7 + 14 = 28`
+
+## Abundant
+
+A number is abundant when it is less than its aliquot sum.
+For example:
+
+- `12` is an abundant number because `1 + 2 + 3 + 4 + 6 = 16`
+- `24` is an abundant number because `1 + 2 + 3 + 4 + 6 + 8 + 12 = 36`
+
+## Deficient
+
+A number is deficient when it is greater than its aliquot sum.
+For example:
+
+- `8` is a deficient number because `1 + 2 + 4 = 7`
+- Prime numbers are deficient
+
+## Task
+
+Implement a way to determine whether a given number is [perfect](#perfect).
+Depending on your language track, you may also need to implement a way to determine whether a given number is [abundant](#abundant) or [deficient](#deficient).
 
 [nicomachus]: https://en.wikipedia.org/wiki/Nicomachus
 [aliquot-sum]: https://en.wikipedia.org/wiki/Aliquot_sum

exercises/practice/pop-count/.meta/config.json

@@ -13,7 +13,7 @@
       ".meta/example.vim"
     ]
   },
-  "blurb": "Count the 1 bits in a number",
+  "blurb": "Help Eliud count the number of eggs in her chicken coop by counting the number of 1 bits in a binary representation.",
   "source": "Christian Willner, Eric Willigers",
   "source_url": "https://forum.exercism.org/t/new-exercise-suggestion-pop-count/7632/5"
 }

exercises/practice/queen-attack/.docs/instructions.md

@@ -8,18 +8,14 @@ A chessboard can be represented by an 8 by 8 array.
 
 So if you are told the white queen is at `c5` (zero-indexed at column 2, row 3) and the black queen at `f2` (zero-indexed at column 5, row 6), then you know that the set-up is like so:
 
-```text
-  a b c d e f g h
-8 _ _ _ _ _ _ _ _ 8
-7 _ _ _ _ _ _ _ _ 7
-6 _ _ _ _ _ _ _ _ 6
-5 _ _ W _ _ _ _ _ 5
-4 _ _ _ _ _ _ _ _ 4
-3 _ _ _ _ _ _ _ _ 3
-2 _ _ _ _ _ B _ _ 2
-1 _ _ _ _ _ _ _ _ 1
-  a b c d e f g h
-```
+![A chess board with two queens. Arrows emanating from the queen at c5 indicate possible directions of capture along file, rank and diagonal.](https://assets.exercism.org/images/exercises/queen-attack/queen-capture.svg)
 
 You are also able to answer whether the queens can attack each other.
 In this case, that answer would be yes, they can, because both pieces share a diagonal.
+
+## Credit
+
+The chessboard image was made by [habere-et-dispertire][habere-et-dispertire] using LaTeX and the [chessboard package][chessboard-package] by Ulrike Fischer.
+
+[habere-et-dispertire]: https://exercism.org/profiles/habere-et-dispertire
+[chessboard-package]: https://github.com/u-fischer/chessboard

exercises/practice/run-length-encoding/.docs/instructions.md

@@ -1,21 +1,20 @@
 # Instructions
 
-Write the function that uses the run-length encoding and decoding algorithms to encode and decode a string.
+Implement run-length encoding and decoding.
 
-Run-length encoding (RLE) is a simple form of data compression where runs of consecutive identical data elements are replaced with one data value and count.
+Run-length encoding (RLE) is a simple form of data compression, where runs (consecutive data elements) are replaced by just one data value and count.
 
-Example:
+For example we can represent the original 53 characters with only 13.
 
+```text
 "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"  ->  "12WB12W3B24WB"
+```
 
 RLE allows the original data to be perfectly reconstructed from the compressed data, which makes it a lossless data compression.
 
-Example:
-
+```text
 "AABCCCDEEEE"  ->  "2AB3CD4E"  ->  "AABCCCDEEEE"
+```
 
-For simplicity, you can assume that the unencoded string will only contain the letters A through Z. (either upper or lower case) and whitespace.
-
-This means that the encoded data will not contain any numbers, so that any numbers contained within data to be decoded will always represent the count for the character that follows it.
-
-
+For simplicity, you can assume that the unencoded string will only contain the letters A through Z (either lower or upper case) and whitespace.
+This way data to be encoded will never contain any numbers and numbers inside data to be decoded always represent the count for the following character.

exercises/practice/transpose/.meta/config.json

@@ -15,5 +15,5 @@
   },
   "blurb": "Take input text and output it transposed.",
   "source": "Reddit r/dailyprogrammer challenge #270 [Easy].",
-  "source_url": "https://www.reddit.com/r/dailyprogrammer/comments/4msu2x/challenge_270_easy_transpose_the_input_text"
+  "source_url": "https://web.archive.org/web/20230630051421/https://old.reddit.com/r/dailyprogrammer/comments/4msu2x/challenge_270_easy_transpose_the_input_text/"
 }

exercises/practice/two-bucket/.docs/instructions.md

@@ -11,7 +11,7 @@ There are some rules that your solution must follow:
      b) the second bucket is full
   2. Emptying a bucket and doing nothing to the other.
   3. Filling a bucket and doing nothing to the other.
-- After an action, you must not arrive at a state where the starting bucket is empty and the other bucket is full.
+- After an action, you may not arrive at a state where the starting bucket is empty and the other bucket is full.
 
 Your program will take as input:
 
@@ -26,7 +26,7 @@ Your program should determine:
 - which bucket should end up with the desired number of liters - either bucket one or bucket two
 - how many liters are left in the other bucket
 
-Note: it counts as one (1) action any time a change is made to either or both buckets.
+Note: any time a change is made to either or both buckets counts as one (1) action.
 
 Example:
 Bucket one can hold up to 7 liters, and bucket two can hold up to 11 liters.
@@ -39,7 +39,7 @@ Bucket one can hold 3 liters, and bucket two can hold up to 5 liters.
 You are told you must start with bucket one.
 So your first action is to fill bucket one.
 You choose to empty bucket one for your second action.
-For your third action, you must not fill bucket two, because this violates the third rule -- you must not end up in a state after any action where the starting bucket is empty and the other bucket is full.
+For your third action, you may not fill bucket two, because this violates the third rule -- you may not end up in a state after any action where the starting bucket is empty and the other bucket is full.
 
 Written with <3 at [Fullstack Academy][fullstack] by Lindsay Levine.