Sync upstream problem-specifications changes

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

@@ -20,7 +20,7 @@ Where:
 
 - `i` is the letter's index from `0` to the length of the alphabet - 1.
 - `m` is the length of the alphabet.
-  For the Roman alphabet `m` is `26`.
+  For the Latin alphabet `m` is `26`.
 - `a` and `b` are integers which make up the encryption key.
 
 Values `a` and `m` must be _coprime_ (or, _relatively prime_) for automatic decryption to succeed, i.e., they have number `1` as their only common factor (more information can be found in the [Wikipedia article about coprime integers][coprime-integers]).

exercises/practice/bottle-song/.meta/config.json

@@ -12,6 +12,9 @@
     ],
     "example": [
       ".meta/Example.cs"
+    ],
+    "invalidator": [
+      "BottleSong.csproj"
     ]
   },
   "blurb": "Produce the lyrics to the popular children's repetitive song: Ten Green Bottles.",

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/flatten-array/.docs/introduction.md

@@ -0,0 +1,7 @@
+# Introduction
+
+A shipment of emergency supplies has arrived, but there's a problem.
+To protect from damage, the items — flashlights, first-aid kits, blankets — are packed inside boxes, and some of those boxes are nested several layers deep inside other boxes!
+
+To be prepared for an emergency, everything must be easily accessible in one box.
+Can you unpack all the supplies and place them into a single box, so they're ready when needed most?

exercises/practice/flatten-array/.meta/tests.toml

@@ -32,12 +32,32 @@ description = "null values are omitted from the final result"
 
 [c6cf26de-8ccd-4410-84bd-b9efd88fd2bc]
 description = "consecutive null values at the front of the list are omitted from the final result"
+include = false
+
+[bc72da10-5f55-4ada-baf3-50e4da02ec8e]
+description = "consecutive null values at the front of the array are omitted from the final result"
+reimplements = "c6cf26de-8ccd-4410-84bd-b9efd88fd2bc"
 
 [382c5242-587e-4577-b8ce-a5fb51e385a1]
 description = "consecutive null values in the middle of the list are omitted from the final result"
+include = false
+
+[6991836d-0d9b-4703-80a0-3f1f23eb5981]
+description = "consecutive null values in the middle of the array are omitted from the final result"
+reimplements = "382c5242-587e-4577-b8ce-a5fb51e385a1"
 
 [ef1d4790-1b1e-4939-a179-51ace0829dbd]
 description = "6 level nest list with null values"
+include = false
+
+[dc90a09c-5376-449c-a7b3-c2d20d540069]
+description = "6 level nested array with null values"
+reimplements = "ef1d4790-1b1e-4939-a179-51ace0829dbd"
 
 [85721643-705a-4150-93ab-7ae398e2942d]
 description = "all values in nested list are null"
+include = false
+
+[51f5d9af-8f7f-4fb5-a156-69e8282cb275]
+description = "all values in nested array are null"
+reimplements = "85721643-705a-4150-93ab-7ae398e2942d"

exercises/practice/flatten-array/FlattenArrayTests.cs

@@ -56,31 +56,31 @@ public void Null_values_are_omitted_from_the_final_result()
     }
 
     [Fact(Skip = "Remove this Skip property to run this test")]
-    public void Consecutive_null_values_at_the_front_of_the_list_are_omitted_from_the_final_result()
+    public void Consecutive_null_values_at_the_front_of_the_array_are_omitted_from_the_final_result()
     {
         object?[] array = new object?[] { null, null, 3 };
         object?[] expected = [3];
         Assert.Equal(expected, FlattenArray.Flatten(array));
     }
 
     [Fact(Skip = "Remove this Skip property to run this test")]
-    public void Consecutive_null_values_in_the_middle_of_the_list_are_omitted_from_the_final_result()
+    public void Consecutive_null_values_in_the_middle_of_the_array_are_omitted_from_the_final_result()
     {
         object?[] array = new object?[] { 1, null, null, 4 };
         object?[] expected = [1, 4];
         Assert.Equal(expected, FlattenArray.Flatten(array));
     }
 
     [Fact(Skip = "Remove this Skip property to run this test")]
-    public void Six_level_nest_list_with_null_values()
+    public void Six_level_nested_array_with_null_values()
     {
         object?[] array = new object?[] { 0, 2, new object?[] { new object?[] { 2, 3 }, 8, new object?[] { new object?[] { 100 } }, null, new object?[] { new object?[] { null } } }, -2 };
         object?[] expected = [0, 2, 2, 3, 8, 100, -2];
         Assert.Equal(expected, FlattenArray.Flatten(array));
     }
 
     [Fact(Skip = "Remove this Skip property to run this test")]
-    public void All_values_in_nested_list_are_null()
+    public void All_values_in_nested_array_are_null()
     {
         object?[] array = new object?[] { null, new object?[] { new object?[] { new object?[] { null } } }, null, null, new object?[] { new object?[] { null, null }, null }, null };
         object?[] expected = [];

exercises/practice/killer-sudoku-helper/.meta/config.json

@@ -11,6 +11,9 @@
     ],
     "example": [
       ".meta/Example.cs"
+    ],
+    "invalidator": [
+      "KillerSudokuHelper.csproj"
     ]
   },
   "blurb": "Write a tool that makes it easier to solve Killer Sudokus",

exercises/practice/saddle-points/.docs/instructions.md

@@ -13,11 +13,12 @@ Or it might have one, or even several.
 Here is a grid that has exactly one candidate tree.
 
 ```text
-    1  2  3  4
-  |-----------
-1 | 9  8  7  8
-2 | 5  3  2  4  <--- potential tree house at row 2, column 1, for tree with height 5
-3 | 6  6  7  1
+      ↓
+      1  2  3  4
+    |-----------
+  1 | 9  8  7  8
+→ 2 |[5] 3  2  4
+  3 | 6  6  7  1
 ```
 
 - Row 2 has values 5, 3, 2, and 4. The largest value is 5.

exercises/practice/satellite/.meta/config.json

@@ -11,6 +11,9 @@
     ],
     "example": [
       ".meta/Example.cs"
+    ],
+    "invalidator": [
+      "Satellite.csproj"
     ]
   },
   "blurb": "Rebuild binary trees from pre-order and in-order traversals."

exercises/practice/sieve/.docs/instructions.md

@@ -6,37 +6,96 @@ A prime number is a number larger than 1 that is only divisible by 1 and itself.
 For example, 2, 3, 5, 7, 11, and 13 are prime numbers.
 By contrast, 6 is _not_ a prime number as it not only divisible by 1 and itself, but also by 2 and 3.
 
-To use the Sieve of Eratosthenes, you first create a list of all the numbers between 2 and your given number.
-Then you repeat the following steps:
+To use the Sieve of Eratosthenes, first, write out all the numbers from 2 up to and including your given number.
+Then, follow these steps:
 
-1. Find the next unmarked number in your list (skipping over marked numbers).
+1. Find the next unmarked number (skipping over marked numbers).
    This is a prime number.
 2. Mark all the multiples of that prime number as **not** prime.
 
-You keep repeating these steps until you've gone through every number in your list.
+Repeat the steps until you've gone through every number.
 At the end, all the unmarked numbers are prime.
 
 ~~~~exercism/note
-The tests don't check that you've implemented the algorithm, only that you've come up with the correct list of primes.
-To check you are implementing the Sieve correctly, a good first test is to check that you do not use division or remainder operations.
+The Sieve of Eratosthenes marks off multiples of each prime using addition (repeatedly adding the prime) or multiplication (directly computing its multiples), rather than checking each number for divisibility.
+
+The tests don't check that you've implemented the algorithm, only that you've come up with the correct primes.
 ~~~~
 
 ## Example
 
 Let's say you're finding the primes less than or equal to 10.
 
-- List out 2, 3, 4, 5, 6, 7, 8, 9, 10, leaving them all unmarked.
+- Write out 2, 3, 4, 5, 6, 7, 8, 9, 10, leaving them all unmarked.
+
+  ```text
+  2 3 4 5 6 7 8 9 10
+  ```
+
 - 2 is unmarked and is therefore a prime.
   Mark 4, 6, 8 and 10 as "not prime".
+
+  ```text
+  2 3 [4] 5 [6] 7 [8] 9 [10]
+  ↑
+  ```
+
 - 3 is unmarked and is therefore a prime.
   Mark 6 and 9 as not prime _(marking 6 is optional - as it's already been marked)_.
+
+  ```text
+  2 3 [4] 5 [6] 7 [8] [9] [10]
+    ↑
+  ```
+
 - 4 is marked as "not prime", so we skip over it.
+
+  ```text
+  2 3 [4] 5 [6] 7 [8] [9] [10]
+       ↑
+  ```
+
 - 5 is unmarked and is therefore a prime.
   Mark 10 as not prime _(optional - as it's already been marked)_.
+
+  ```text
+  2 3 [4] 5 [6] 7 [8] [9] [10]
+          ↑
+  ```
+
 - 6 is marked as "not prime", so we skip over it.
+
+  ```text
+  2 3 [4] 5 [6] 7 [8] [9] [10]
+             ↑
+  ```
+
 - 7 is unmarked and is therefore a prime.
+
+  ```text
+  2 3 [4] 5 [6] 7 [8] [9] [10]
+                ↑
+  ```
+
 - 8 is marked as "not prime", so we skip over it.
+
+  ```text
+  2 3 [4] 5 [6] 7 [8] [9] [10]
+                   ↑
+  ```
+
 - 9 is marked as "not prime", so we skip over it.
+
+  ```text
+  2 3 [4] 5 [6] 7 [8] [9] [10]
+                       ↑
+  ```
+
 - 10 is marked as "not prime", so we stop as there are no more numbers to check.
 
-You've examined all numbers and found 2, 3, 5, and 7 are still unmarked, which means they're the primes less than or equal to 10.
+  ```text
+  2 3 [4] 5 [6] 7 [8] [9] [10]
+                           ↑
+  ```
+
+You've examined all the numbers and found that 2, 3, 5, and 7 are still unmarked, meaning they're the primes less than or equal to 10.

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

@@ -11,14 +11,14 @@ If anyone wishes to decipher these, and get at their meaning, he must substitute
 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.
 
-The Caesar Cipher was used for some messages from Julius Caesar that were sent afield.
+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.
 
-Your task is to create a simple shift cipher like the Caesar Cipher.
-This image is a great example of the Caesar Cipher:
+Your task is to create a simple shift cipher like the Caesar cipher.
+This image is a great example of the Caesar cipher:
 
-![Caesar Cipher][img-caesar-cipher]
+![Caesar cipher][img-caesar-cipher]
 
 For example:
 
@@ -44,7 +44,7 @@ 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.
+But if we set the key to "dddd", we would get the same thing as the Caesar cipher.
 
 ## Step 3
 

exercises/practice/state-of-tic-tac-toe/.meta/config.json

@@ -11,6 +11,9 @@
     ],
     "example": [
       ".meta/Example.cs"
+    ],
+    "invalidator": [
+      "StateOfTicTacToe.csproj"
     ]
   },
   "blurb": "Determine the game state of a match of Tic-Tac-Toe.",