Merge branch 'exercism:main' into update-wordy-approaches

Author: BethanyG

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/crypto-square/.meta/tests.toml

@@ -32,3 +32,8 @@ description = "8 character plaintext results in 3 chunks, the last one with a tr
 
 [fbcb0c6d-4c39-4a31-83f6-c473baa6af80]
 description = "54 character plaintext results in 7 chunks, the last two with trailing spaces"
+include = false
+
+[33fd914e-fa44-445b-8f38-ff8fbc9fe6e6]
+description = "54 character plaintext results in 8 chunks, the last two with trailing spaces"
+reimplements = "fbcb0c6d-4c39-4a31-83f6-c473baa6af80"

exercises/practice/crypto-square/crypto_square_test.py

@@ -1,6 +1,6 @@
 # These tests are auto-generated with test data from:
 # https://github.com/exercism/problem-specifications/tree/main/exercises/crypto-square/canonical-data.json
-# File last updated on 2023-07-19
+# File last updated on 2025-06-20
 
 import unittest
 
@@ -47,7 +47,7 @@ def test_8_character_plaintext_results_in_3_chunks_the_last_one_with_a_trailing_
         expected = "clu hlt io "
         self.assertEqual(cipher_text(value), expected)
 
-    def test_54_character_plaintext_results_in_7_chunks_the_last_two_with_trailing_spaces(
+    def test_54_character_plaintext_results_in_8_chunks_the_last_two_with_trailing_spaces(
         self,
     ):
         value = "If man was meant to stay on the ground, god would have given us roots."

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/largest-series-product/.meta/example.py

@@ -5,7 +5,7 @@
 def slices(series, size):
 
     if not size <= len(series):
-        raise ValueError('span must be smaller than string length')
+        raise ValueError('span must not exceed string length')
     elif not 0 < size:
         raise ValueError('span must not be negative')
     elif not all(item.isdigit() for item in series):
@@ -20,4 +20,4 @@ def slices(series, size):
 def largest_product(series, size):
     if size == 0:
         return 1
-    return max(reduce(mul, slice) for slice in slices(series, size))
+    return max(reduce(mul, slice) for slice in slices(series, size))

exercises/practice/largest-series-product/.meta/tests.toml

@@ -38,6 +38,11 @@ description = "reports zero if all spans include zero"
 
 [5d81aaf7-4f67-4125-bf33-11493cc7eab7]
 description = "rejects span longer than string length"
+include = false
+
+[0ae1ce53-d9ba-41bb-827f-2fceb64f058b]
+description = "rejects span longer than string length"
+reimplements = "5d81aaf7-4f67-4125-bf33-11493cc7eab7"
 
 [06bc8b90-0c51-4c54-ac22-3ec3893a079e]
 description = "reports 1 for empty string and empty product (0 span)"
@@ -49,6 +54,11 @@ include = false
 
 [6d96c691-4374-4404-80ee-2ea8f3613dd4]
 description = "rejects empty string and nonzero span"
+include = false
+
+[6cf66098-a6af-4223-aab1-26aeeefc7402]
+description = "rejects empty string and nonzero span"
+reimplements = "6d96c691-4374-4404-80ee-2ea8f3613dd4"
 
 [7a38f2d6-3c35-45f6-8d6f-12e6e32d4d74]
 description = "rejects invalid character in digits"

exercises/practice/largest-series-product/largest_series_product_test.py

@@ -1,6 +1,6 @@
 # These tests are auto-generated with test data from:
 # https://github.com/exercism/problem-specifications/tree/main/exercises/largest-series-product/canonical-data.json
-# File last updated on 2023-07-19
+# File last updated on 2025-06-20
 
 import unittest
 
@@ -44,17 +44,13 @@ def test_rejects_span_longer_than_string_length(self):
         with self.assertRaises(ValueError) as err:
             largest_product("123", 4)
         self.assertEqual(type(err.exception), ValueError)
-        self.assertEqual(
-            err.exception.args[0], "span must be smaller than string length"
-        )
+        self.assertEqual(err.exception.args[0], "span must not exceed string length")
 
     def test_rejects_empty_string_and_nonzero_span(self):
         with self.assertRaises(ValueError) as err:
             largest_product("", 1)
         self.assertEqual(type(err.exception), ValueError)
-        self.assertEqual(
-            err.exception.args[0], "span must be smaller than string length"
-        )
+        self.assertEqual(err.exception.args[0], "span must not exceed string length")
 
     def test_rejects_invalid_character_in_digits(self):
         with self.assertRaises(ValueError) as err:

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 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

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.