From 4742d3ec895689cc9a3ef29d9cdcd47b24e75220 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 2 Dec 2025 21:00:38 -0800
Subject: [PATCH 01/12] Bump actions/checkout from 5.0.0 to 6.0.0 (#4034)

Bumps [actions/checkout](https://github.com/actions/checkout) from 5.0.0 to 6.0.0.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/08c6903cd8c0fde910a37f88322edcfb5dd907a8...1af3b93b6815bc44a9784bd300feb67ff0d1eeb3)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: 6.0.0
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci-workflow.yml     | 4 ++--
 .github/workflows/issue-commenter.yml | 2 +-
 .github/workflows/test-runner.yml     | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci-workflow.yml b/.github/workflows/ci-workflow.yml
index 3a80387e3a5..0ad6f1f3139 100644
--- a/.github/workflows/ci-workflow.yml
+++ b/.github/workflows/ci-workflow.yml
@@ -14,7 +14,7 @@ jobs:
   housekeeping:
     runs-on: ubuntu-24.04
     steps:
-    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8
+    - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3
 
     - name: Set up Python
       uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c
@@ -55,7 +55,7 @@ jobs:
       matrix:
         python-version: [3.7, 3.8, 3.9, 3.10.6, 3.11.2]
     steps:
-    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8
+    - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3
 
     - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c
       with:
diff --git a/.github/workflows/issue-commenter.yml b/.github/workflows/issue-commenter.yml
index 5472e7d95e7..4f6bff60471 100644
--- a/.github/workflows/issue-commenter.yml
+++ b/.github/workflows/issue-commenter.yml
@@ -9,7 +9,7 @@ jobs:
     name: Comments for every NEW issue.
     steps:
       - name: Checkout
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3
 
       - name: Read issue-comment.md
         id: issue-comment
diff --git a/.github/workflows/test-runner.yml b/.github/workflows/test-runner.yml
index 428be225caa..97fcf6e5be3 100644
--- a/.github/workflows/test-runner.yml
+++ b/.github/workflows/test-runner.yml
@@ -10,6 +10,6 @@ jobs:
   test-runner:
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3
       - name: Run test-runner
         run: docker compose run test-runner

From f5ee289c41aadd39db56ffcbcee9fd4fba9243cb Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 2 Dec 2025 21:01:15 -0800
Subject: [PATCH 02/12] Bump actions/setup-python from 6.0.0 to 6.1.0 (#4035)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 6.0.0 to 6.1.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/e797f83bcb11b83ae66e0230d6156d7c80228e7c...83679a892e2d95755f2dac6acb0bfd1e9ac5d548)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-version: 6.1.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci-workflow.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci-workflow.yml b/.github/workflows/ci-workflow.yml
index 0ad6f1f3139..e853469c6d0 100644
--- a/.github/workflows/ci-workflow.yml
+++ b/.github/workflows/ci-workflow.yml
@@ -17,7 +17,7 @@ jobs:
     - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3
 
     - name: Set up Python
-      uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c
+      uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548
       with:
         python-version: 3.11.2
 
@@ -57,7 +57,7 @@ jobs:
     steps:
     - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3
 
-    - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c
+    - uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548
       with:
         python-version: ${{ matrix.python-version }}
 

From dcbfdef0aa7a2fbd5e514347c23636e1c08ab660 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 20 Dec 2025 08:44:26 -0800
Subject: [PATCH 03/12] Bump actions/stale from 10.0.0 to 10.1.0 (#4020)

Bumps [actions/stale](https://github.com/actions/stale) from 10.0.0 to 10.1.0.
- [Release notes](https://github.com/actions/stale/releases)
- [Changelog](https://github.com/actions/stale/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/stale/compare/3a9db7e6a41a89f618792c92c0e97cc736e1b13f...5f858e3efba33a5ca4407a664cc011ad407f2008)

---
updated-dependencies:
- dependency-name: actions/stale
  dependency-version: 10.1.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/stale.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
index 1c4ddca6a9a..4a5a9a772f1 100644
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@@ -8,7 +8,7 @@ jobs:
   stale:
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/stale@3a9db7e6a41a89f618792c92c0e97cc736e1b13f
+      - uses: actions/stale@5f858e3efba33a5ca4407a664cc011ad407f2008
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           days-before-stale: 21

From d069b5db6e9bd791264946c3683bbbfffab49e28 Mon Sep 17 00:00:00 2001
From: PetreM <petrem@users.noreply.github.com>
Date: Sun, 21 Dec 2025 23:25:30 +0200
Subject: [PATCH 04/12] robot-name approach: fix typos, minor
 rephrasing/improvements (#4051)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* robot-name approach: fix typos, minor rephasing/improvements

- Fixed a few typos.
- Rephrased here and there where I subjectively thought it useful. Please let me know if
 they're undesirable.
- Expanded some contractions - this might help non-native speakers.
- When another approach is mentioned, added link to it - hopefully this is useful rather
  than an distraction
- I thought the explanation about the alternative to using the walrus operator was not
  clear, so rephrased and added a code snippet. I hope this is useful.

* Update exercises/practice/robot-name/.approaches/mass-name-generation/content.md

Co-authored-by: BethanyG <BethanyG@users.noreply.github.com>

* Update exercises/practice/robot-name/.approaches/mass-name-generation/content.md

Co-authored-by: BethanyG <BethanyG@users.noreply.github.com>

* Update exercises/practice/robot-name/.approaches/mass-name-generation/content.md

Co-authored-by: BethanyG <BethanyG@users.noreply.github.com>

* Update exercises/practice/robot-name/.approaches/mass-name-generation/content.md

Co-authored-by: BethanyG <BethanyG@users.noreply.github.com>

* Update exercises/practice/robot-name/.approaches/name-on-the-fly/content.md

Co-authored-by: BethanyG <BethanyG@users.noreply.github.com>

* Update exercises/practice/robot-name/.approaches/name-on-the-fly/content.md

Co-authored-by: BethanyG <BethanyG@users.noreply.github.com>

* Update exercises/practice/robot-name/.approaches/mass-name-generation/content.md

Co-authored-by: András B Nagy <20251272+BNAndras@users.noreply.github.com>

* blank lines after headers and remove trailing whitespace

* add blank lines around code snippets and expand one more contraction

---------

Co-authored-by: BethanyG <BethanyG@users.noreply.github.com>
Co-authored-by: András B Nagy <20251272+BNAndras@users.noreply.github.com>
---
 .../robot-name/.approaches/introduction.md    | 12 ++++--
 .../mass-name-generation/content.md           | 21 +++++-----
 .../.approaches/name-on-the-fly/content.md    | 39 +++++++++++++------
 3 files changed, 48 insertions(+), 24 deletions(-)

diff --git a/exercises/practice/robot-name/.approaches/introduction.md b/exercises/practice/robot-name/.approaches/introduction.md
index c4b67383801..d0140e65348 100644
--- a/exercises/practice/robot-name/.approaches/introduction.md
+++ b/exercises/practice/robot-name/.approaches/introduction.md
@@ -1,12 +1,15 @@
 # Introduction
-Robot Name in Python is an interesting exercise for practising randomness.
+
+Robot Name in Python is an interesting exercise for practicing randomness.
 
 ## General Guidance
-Two ways immedietely come to mind: generate all the possible names and then return them sequentially, or generate a random name and ensure that it's not been previously used.
+
+Two ways immediately come to mind: generate all the possible names and then return them sequentially, or generate a random name and ensure that it has not been previously used.
 
 Randomness can be a little, well, random, so **it's very easy to have an incorrect solution and still pass the tests**. It's strongly recommended to submit your solution for Code Review.
 
 ## Approach: mass name generation
+
 We'd first have to generate all the possible names, shuffle them, and then use `next` (the simplest way) or maintain a `current_index` and get the name.
 Here's a possible way to do it:
 
@@ -26,14 +29,17 @@ class Robot(object):
     def reset(self):
         self.name = next(NAMES)
 ```
+
 Note that selecting randomly from the list of all names would be incorrect, as there's a possibility of the name being repeated.
 For more detail and explanation of the code, [read here][approach-mass-name-generation].
 
 ## Approach: name on the fly
-Another approach is to generate the name on the fly and add it to a cache or a store, and checking if the generated name hasn't been used previously.
+
+Another approach is to generate the name on the fly and add it to a cache or a store, checking if the generated name hasn't been used previously.
 
 
 A possible way to implement this:
+
 ```python
 from string import ascii_uppercase, digits
 from random import choices
diff --git a/exercises/practice/robot-name/.approaches/mass-name-generation/content.md b/exercises/practice/robot-name/.approaches/mass-name-generation/content.md
index 392a34ca197..a245195fa50 100644
--- a/exercises/practice/robot-name/.approaches/mass-name-generation/content.md
+++ b/exercises/practice/robot-name/.approaches/mass-name-generation/content.md
@@ -1,8 +1,9 @@
 # Mass Name Generation
-We'd first have to generate all the possible names, shuffle them, and then use `next` (the simplest way) or maintain a `current_index` and get the name.
-Note that selecting randomly from the list of all names would be incorrect, as there's a possibility of the name being repeated.
 
-Here's a possible way to do it:
+We first generate all the possible names, shuffle them, and then either use `next` (the simplest way) or maintain a `current_index` to get the name.
+Note that selecting randomly from the list of all names would be incorrect, as there is a possibility of the name being repeated.
+
+One possible way to do it:
 
 ```python
 from itertools import product
@@ -25,25 +26,27 @@ class Robot(object):
 
 The first few lines of the mass name generation uses [`itertools.product`][itertools-product].
 The resultant code is a simplification of:
+
 ```python
 letter_pairs = (''.join((l1, l2)) for l1 in ascii_uppercase for l2 in ascii_uppercase)
 numbers = (str(i).zfill(3) for i in range(1000))
 names = [l + n for l in letter_pairs for n in numbers]
 ```
 
-After the name generation, the names are shuffled - using the [default `seed`][random-seed] in the `random` module (the current timestamp). 
+After the name generation, the names are shuffled - using the [default `seed`][random-seed] in the `random` module (the current timestamp).
 When the tests reseed `random`, this has no effect as the names were shuffled before that.
 
-We then set `NAMES` to the iterable of names, and in `reset`, set the robot's name to the  `next(name)`. 
-If you'd like, read more on [`iter` and `next`][iter-and-next].
+We then set `NAMES` to the iterable of names, and in `reset`, set the robot's name to the  `next(name)`.
+If you are interested, you can read more on [`iter` and `next`][iter-and-next].
 
-Unlike the on the fly approach, this has a relatively short "generation" time, because we're merely giving the `next` name instead of generating it.
-However, this has a huge startup memory and time cost, as 676,000 strings have to be calculated and stored. 
+Unlike the [on the fly approach][approach-name-on-the-fly], this has a relatively short "generation" time, because we are merely giving the `next` name instead of generating it.
+However, this has a huge startup memory and time cost, as 676,000 strings have to be calculated and stored.
 For an approximate calculation, 676,000 strings * 5 characters / string * 1 byte / character gives 3380000 bytes or 3.38 MB of RAM - and that's just the memory aspect of it.
-Sounds small, but it's relatively very expensive at the beginning.
+Sounds small, but this might be a relatively significant startup cost.
 
 Thus, this approach is inefficient in cases where only a small number of names are needed _and_ the time to set/reset the robot isn't crucial.
 
 [random-seed]: https://docs.python.org/3/library/random.html#random.seed
 [iter-and-next]: https://www.programiz.com/python-programming/methods/built-in/iter
 [itertools-product]: https://www.hackerrank.com/challenges/itertools-product/problem
+[approach-name-on-the-fly]: https://exercism.org/tracks/python/exercises/robot-name/approaches/name-on-the-fly
diff --git a/exercises/practice/robot-name/.approaches/name-on-the-fly/content.md b/exercises/practice/robot-name/.approaches/name-on-the-fly/content.md
index 0aa9f9a3fab..494b32b2d10 100644
--- a/exercises/practice/robot-name/.approaches/name-on-the-fly/content.md
+++ b/exercises/practice/robot-name/.approaches/name-on-the-fly/content.md
@@ -1,7 +1,9 @@
 # Find name on the fly
-We generate the name on the fly and add it to a cache or a store, and checking if the generated name hasn't been used previously.
+
+We generate the name on the fly and add it to a cache or a store, checking to make sure that the generated name has not been used previously.
 
 A possible way to implement this:
+
 ```python
 from string import ascii_uppercase, digits
 from random import choices
@@ -10,7 +12,7 @@ cache = set()
 
 
 class Robot:
-    def __get_name(self): 
+    def __get_name(self):
         return ''.join(choices(ascii_uppercase, k=2) + choices(digits, k=3))
 
     def reset(self):
@@ -19,18 +21,30 @@ class Robot:
         cache.add(name)
         self.name = name
 
-    def __init__(self): 
+    def __init__(self):
         self.reset()
 ```
-We use a `set` for the cache as it has a low access time, and we don't need the preservation of order or the ability to be indexed.
 
-This way is merely one of the many to generate the name. 
+We use a `set` for the cache as it has a low access time, and because we do not need the preservation of order or the ability to access by index.
+
+Using `choices` is one of the many ways to generate the name.
 Another way might be to use `randrange` along with `zfill` for the number part, and a double `random.choice` / `random.choice` on `itertools.product` to generate the letter part.
-This is the shortest way, and best utilizes the Python standard library.
+The first is shorter, and best utilizes the Python standard library.
+
+As we are using a `while` loop to check for the name generation, it is convenient to store the local `name` using the [walrus operator][walrus-operator].
+It's also possible to find the name once before the loop, and then find it again inside the loop, but that would be an unnecessary repetition:
+
+```python
+def reset(self):
+    name = self.__get_name()
+    while name in cache:
+        name = self.__get_name()
+    cache.add(name)
+    self.name = name
+```
 
-As we're using a `while` loop to check for the name generation, it's convenient to store the local `name` using the [walrus operator][walrus-operator].
-It's also possible to find the name before the loop and find it again inside the loop, but that would unnecessary repetition.
 A helper method ([private][private-helper-methods] in this case) makes your code cleaner, but it's equally valid to have the code in the loop itself:
+
 ```python
 def reset(self):
     while (name := ''.join(choices(ascii_uppercase, k=2) + choices(digits, k=3))) in cache:
@@ -39,14 +53,15 @@ def reset(self):
     self.name = name
 ```
 
-We call `reset` from `__init__` - it's syntactically valid to do it the other way round, but it's not considered good practice to call [dunder methods][dunder-methods] directly.
+We call `reset` from `__init__` - it is syntactically valid to do it the other way around, but it is not considered good practice to call [dunder methods][dunder-methods] directly.
 
 This has almost no startup time and memory, apart from declaring an empty `set`.
-Note that the _generation_ time is the same as the mass generation approach, as a similar method is used.
+Note that the _generation_ time is the same as the [mass generation approach][approach-mass-name-generation], as a similar method is used.
 However, as the name is generated at the time of setting/resetting, the method time itself is higher.
 
-In the long run, if many names are generated, this is inefficient, since collisions will start being generated more often than unique names. 
+In the long run, if many names are generated, this is inefficient, since collisions will start being generated more often than unique names.
 
 [walrus-operator]: https://realpython.com/python-walrus-operator/
 [private-helper-methods]: https://www.geeksforgeeks.org/private-methods-in-python/
-[dunder-methods]: https://dbader.org/blog/python-dunder-methods
\ No newline at end of file
+[dunder-methods]: https://dbader.org/blog/python-dunder-methods
+[approach-mass-name-generation]: https://exercism.org/tracks/python/exercises/robot-name/approaches/mass-name-generation

From 6865784f3f7abda58aa593668cb312ebd4921cc0 Mon Sep 17 00:00:00 2001
From: PetreM <petrem@users.noreply.github.com>
Date: Thu, 25 Dec 2025 00:37:50 +0200
Subject: [PATCH 05/12] rna-transcription approach: a few improvements (#4052)

* rna-transcription approach: a few improvements

- Renamed `chr` to `char` in the snippets because `chr` is a built-in function and
  although shadowing it in this case may not be a problem, it is still a bad practice
  when it can be avoided.
- The dictionary-join approach mentions list comprehensions, but instead it uses a
  generator expression. Replaced this in the explanation and expanded to give the list
  comprehension based implementation along with a brief comparison.
- The overview mentions one approach is four times faster. In a brief comparison, it
  varies from 2.5x for a very short string and up to 60x faster for a 10^6 long one.
  Probably not worth going into the details, but 4x is just innacurate.

* convert code snippets to single quotes for consistency

* several updates following discussions

- Replaced `char` with `nucleotide` as this is terminology from the domain.
- Rephrased a "see also" link to be more screen reader friendly.
- A note about the exercise not requiring tests for invalid characters is preset in one
  of the approaches. Copied it over to the other approach, for uniformity.
- Rephrased mention about performance and speedup.
- Replaced mention of ASCII with Unicode adding a brief explanation and links.

* move note regarding testing for erroneous inputs to `introduction.md`
... because it applies to the exercise in general, not a particular approach.

Re-applying missed commits from prior cherry-pick.

* Re-applied the commits from below via cherry-pick.
convert code snippets to single quotes for consistency
---
 .../.approaches/dictionary-join/content.md    | 32 ++++++++++++++++---
 .../.approaches/dictionary-join/snippet.txt   |  4 +--
 .../.approaches/introduction.md               | 18 +++++++----
 .../translate-maketrans/content.md            | 17 +++++-----
 .../translate-maketrans/snippet.txt           |  2 +-
 5 files changed, 51 insertions(+), 22 deletions(-)

diff --git a/exercises/practice/rna-transcription/.approaches/dictionary-join/content.md b/exercises/practice/rna-transcription/.approaches/dictionary-join/content.md
index f3ec1f755fb..fcf0c58953a 100644
--- a/exercises/practice/rna-transcription/.approaches/dictionary-join/content.md
+++ b/exercises/practice/rna-transcription/.approaches/dictionary-join/content.md
@@ -1,11 +1,11 @@
 # dictionary look-up with `join`
 
 ```python
-LOOKUP = {"G": "C", "C": "G", "T": "A", "A": "U"}
+LOOKUP = {'G': 'C', 'C': 'G', 'T': 'A', 'A': 'U'}
 
 
 def to_rna(dna_strand):
-    return ''.join(LOOKUP[chr] for chr in dna_strand)
+    return ''.join(LOOKUP[nucleotide] for nucleotide in dna_strand)
 
 ```
 
@@ -16,15 +16,37 @@ but the `LOOKUP` dictionary is defined with all uppercase letters, which is the
 It indicates that the value is not intended to be changed.
 
 In the `to_rna()` function, the [`join()`][join] method is called on an empty string,
-and is passed the list created from a [list comprehension][list-comprehension].
+and is passed the list created from a [generator expression][generator-expression].
 
-The list comprehension iterates each character in the input,
+The generator expression iterates each character in the input,
 looks up the DNA character in the look-up dictionary, and outputs its matching RNA character as an element in the list.
 
-The `join()` method collects the list of RNA characters back into a string.
+The `join()` method collects the RNA characters back into a string.
 Since an empty string is the separator for the `join()`, there are no spaces between the RNA characters in the string.
 
+A generator expression is similar to a [list comprehension][list-comprehension], but instead of creating a list, it returns a generator, and iterating that generator yields the elements on the fly.
+
+A variant that uses a list comprehension is almost identical, but note the additional square brackets inside the `join()`:
+
+```python
+LOOKUP = {'G': 'C', 'C': 'G', 'T': 'A', 'A': 'U'}
+
+def to_rna(dna_strand):
+    return ''.join([LOOKUP[nucleotide] for nucleotide in dna_strand])
+```
+
+
+For a relatively small number of elements, using lists is fine and may be faster, but as the number of elements increases, the memory consumption increases and performance decreases.
+You can read more about [when to choose generators over list comprehensions][list-comprehension-choose-generator-expression] to dig deeper into the topic.
+
+
+~~~~exercism/note
+As of this writing, no invalid DNA characters are in the argument to `to_rna()`, so there is no error handling required for invalid input.
+~~~~
+
 [dictionaries]: https://docs.python.org/3/tutorial/datastructures.html?#dictionaries
 [const]: https://realpython.com/python-constants/
 [join]: https://docs.python.org/3/library/stdtypes.html?#str.join
 [list-comprehension]: https://realpython.com/list-comprehension-python/#using-list-comprehensions
+[list-comprehension-choose-generator-expression]: https://realpython.com/list-comprehension-python/#choose-generators-for-large-datasets
+[generator-expression]: https://realpython.com/introduction-to-python-generators/#building-generators-with-generator-expressions
diff --git a/exercises/practice/rna-transcription/.approaches/dictionary-join/snippet.txt b/exercises/practice/rna-transcription/.approaches/dictionary-join/snippet.txt
index 558bf981408..398f2dfb07f 100644
--- a/exercises/practice/rna-transcription/.approaches/dictionary-join/snippet.txt
+++ b/exercises/practice/rna-transcription/.approaches/dictionary-join/snippet.txt
@@ -1,5 +1,5 @@
-LOOKUP = {"G": "C", "C": "G", "T": "A", "A": "U"}
+LOOKUP = {'G': 'C', 'C': 'G', 'T': 'A', 'A': 'U'}
 
 
 def to_rna(dna_strand):
-    return ''.join(LOOKUP[chr] for chr in dna_strand)
+    return ''.join(LOOKUP[nucleotide] for nucleotide in dna_strand)
diff --git a/exercises/practice/rna-transcription/.approaches/introduction.md b/exercises/practice/rna-transcription/.approaches/introduction.md
index ca2d74a1090..54b4c1f7d30 100644
--- a/exercises/practice/rna-transcription/.approaches/introduction.md
+++ b/exercises/practice/rna-transcription/.approaches/introduction.md
@@ -7,13 +7,13 @@ Another approach is to do a dictionary lookup on each character and join the res
 ## General guidance
 
 Whichever approach is used needs to return the RNA complement for each DNA value.
-The `translate()` method with `maketrans()` transcribes using the [ASCII][ASCII] values of the characters.
+The `translate()` method with `maketrans()` transcribes using the [Unicode][Unicode] code points of the characters.
 Using a dictionary look-up with `join()` transcribes using the string values of the characters.
 
 ## Approach: `translate()` with `maketrans()`
 
 ```python
-LOOKUP = str.maketrans("GCTA", "CGAU")
+LOOKUP = str.maketrans('GCTA', 'CGAU')
 
 
 def to_rna(dna_strand):
@@ -26,11 +26,11 @@ For more information, check the [`translate()` with `maketrans()` approach][appr
 ## Approach: dictionary look-up with `join()`
 
 ```python
-LOOKUP = {"G": "C", "C": "G", "T": "A", "A": "U"}
+LOOKUP = {'G': 'C', 'C': 'G', 'T': 'A', 'A': 'U'}
 
 
 def to_rna(dna_strand):
-    return ''.join(LOOKUP[chr] for chr in dna_strand)
+    return ''.join(LOOKUP[nucleotide] for nucleotide in dna_strand)
 
 ```
 
@@ -38,8 +38,14 @@ For more information, check the [dictionary look-up with `join()` approach][appr
 
 ## Which approach to use?
 
-The `translate()` with `maketrans()` approach benchmarked over four times faster than the dictionary look-up with `join()` approach.
+If performance matters, consider using the [`translate()` with `maketrans()` approach][approach-translate-maketrans].
+How an implementation behaves in terms of performance may depend on the actual data being processed, on hardware, and other factors.
 
-[ASCII]: https://www.asciitable.com/
+
+~~~~exercism/note
+As of this writing, no invalid DNA characters are in the argument to `to_rna()`, so there is no error handling required for invalid input.
+~~~~
+
+[Unicode]: https://en.wikipedia.org/wiki/Unicode
 [approach-translate-maketrans]: https://exercism.org/tracks/python/exercises/rna-transcription/approaches/translate-maketrans
 [approach-dictionary-join]: https://exercism.org/tracks/python/exercises/rna-transcription/approaches/dictionary-join
diff --git a/exercises/practice/rna-transcription/.approaches/translate-maketrans/content.md b/exercises/practice/rna-transcription/.approaches/translate-maketrans/content.md
index 9b484e3cb55..9373cf12b26 100644
--- a/exercises/practice/rna-transcription/.approaches/translate-maketrans/content.md
+++ b/exercises/practice/rna-transcription/.approaches/translate-maketrans/content.md
@@ -1,7 +1,7 @@
 # `translate()` with `maketrans()`
 
 ```python
-LOOKUP = str.maketrans("GCTA", "CGAU")
+LOOKUP = str.maketrans('GCTA', 'CGAU')
 
 
 def to_rna(dna_strand):
@@ -15,20 +15,21 @@ Python doesn't _enforce_ having real constant values,
 but the `LOOKUP` translation table is defined with all uppercase letters, which is the naming convention for a Python [constant][const].
 It indicates that the value is not intended to be changed.
 
-The translation table that is created uses the [ASCII][ASCII] values (also called the ordinal values) for each letter in the two strings.
-The ASCII value for "G" in the first string is the key for the ASCII value of "C" in the second string, and so on.
+The translation table that is created uses the [Unicode][Unicode] _code points_ (sometimes called the ordinal values) for each letter in the two strings.
+As Unicode was designed to be backwards compatible with [ASCII][ASCII] and because the exercise uses Latin letters, the code points in the translation table can be interpreted as ASCII.
+However, the functions can deal with any Unicode character.
+You can learn more by reading about [strings and their representation in the Exercism Python syllabus][concept-string].
+
+The Unicode value for "G" in the first string is the key for the Unicode value of "C" in the second string, and so on.
 
 In the `to_rna()` function, the [`translate()`][translate] method is called on the input,
 and is passed the translation table.
 The output of `translate()` is a string where all of the input DNA characters have been replaced by their RNA complement in the translation table.
 
-
-~~~~exercism/note
-As of this writing, no invalid DNA characters are in the argument to `to_rna()`, so there is no error handling required for invalid input.
-~~~~
-
 [dictionaries]: https://docs.python.org/3/tutorial/datastructures.html?#dictionaries
 [maketrans]: https://docs.python.org/3/library/stdtypes.html?#str.maketrans
 [const]: https://realpython.com/python-constants/
 [translate]: https://docs.python.org/3/library/stdtypes.html?#str.translate
 [ASCII]: https://www.asciitable.com/
+[Unicode]: https://en.wikipedia.org/wiki/Unicode
+[concept-strings]: https://exercism.org/tracks/python/concepts/strings
diff --git a/exercises/practice/rna-transcription/.approaches/translate-maketrans/snippet.txt b/exercises/practice/rna-transcription/.approaches/translate-maketrans/snippet.txt
index 2d00b83be6b..db15d868f19 100644
--- a/exercises/practice/rna-transcription/.approaches/translate-maketrans/snippet.txt
+++ b/exercises/practice/rna-transcription/.approaches/translate-maketrans/snippet.txt
@@ -1,4 +1,4 @@
-LOOKUP = str.maketrans("GCTA", "CGAU")
+LOOKUP = str.maketrans('GCTA', 'CGAU')
 
 
 def to_rna(dna_strand):

From 0410dcc8527539be0f5707f2079bd888f2e0888c Mon Sep 17 00:00:00 2001
From: BethanyG <BethanyG@users.noreply.github.com>
Date: Tue, 30 Dec 2025 13:55:45 -0800
Subject: [PATCH 06/12] December 2025 practice exercise docs sync. (#4058)

Pulled in latest exercise introductions and instructions from problem-specifications.
---
 .../.docs/instructions.md                     |  2 +-
 .../ocr-numbers/.docs/instructions.md         | 80 ++++++-------------
 .../ocr-numbers/.docs/introduction.md         |  6 ++
 .../practice/triangle/.docs/instructions.md   |  3 +-
 4 files changed, 33 insertions(+), 58 deletions(-)
 create mode 100644 exercises/practice/ocr-numbers/.docs/introduction.md

diff --git a/exercises/practice/killer-sudoku-helper/.docs/instructions.md b/exercises/practice/killer-sudoku-helper/.docs/instructions.md
index fdafdca8fbe..9f5cb1368ff 100644
--- a/exercises/practice/killer-sudoku-helper/.docs/instructions.md
+++ b/exercises/practice/killer-sudoku-helper/.docs/instructions.md
@@ -74,7 +74,7 @@ You can also find Killer Sudokus in varying difficulty in numerous newspapers, a
 
 ## Credit
 
-The screenshots above have been generated using [F-Puzzles.com](https://www.f-puzzles.com/), a Puzzle Setting Tool by Eric Fox.
+The screenshots above have been generated using F-Puzzles.com, a Puzzle Setting Tool by Eric Fox.
 
 [sudoku-rules]: https://masteringsudoku.com/sudoku-rules-beginners/
 [killer-guide]: https://masteringsudoku.com/killer-sudoku/
diff --git a/exercises/practice/ocr-numbers/.docs/instructions.md b/exercises/practice/ocr-numbers/.docs/instructions.md
index 7beb2577957..8a391ce4f6e 100644
--- a/exercises/practice/ocr-numbers/.docs/instructions.md
+++ b/exercises/practice/ocr-numbers/.docs/instructions.md
@@ -1,79 +1,47 @@
 # Instructions
 
-Given a 3 x 4 grid of pipes, underscores, and spaces, determine which number is represented, or whether it is garbled.
+Optical Character Recognition or OCR is software that converts images of text into machine-readable text.
+Given a grid of characters representing some digits, convert the grid to a string of digits.
+If the grid has multiple rows of cells, the rows should be separated in the output with a `","`.
 
-## Step One
+- The grid is made of one of more lines of cells.
+- Each line of the grid is made of one or more cells.
+- Each cell is three columns wide and four rows high (3x4) and represents one digit.
+- Digits are drawn using pipes (`"|"`), underscores (`"_"`), and spaces (`" "`).
 
-To begin with, convert a simple binary font to a string containing 0 or 1.
+## Edge cases
 
-The binary font uses pipes and underscores, four rows high and three columns wide.
+- If the input is not a valid size, your program should indicate there is an error.
+- If the input is the correct size, but a cell is not recognizable, your program should output a `"?"` for that character.
 
-```text
-     _   #
-    | |  # zero.
-    |_|  #
-         # the fourth row is always blank
-```
+## Examples
 
-Is converted to "0"
-
-```text
-         #
-      |  # one.
-      |  #
-         # (blank fourth row)
-```
-
-Is converted to "1"
-
-If the input is the correct size, but not recognizable, your program should return '?'
-
-If the input is the incorrect size, your program should return an error.
-
-## Step Two
-
-Update your program to recognize multi-character binary strings, replacing garbled numbers with ?
-
-## Step Three
-
-Update your program to recognize all numbers 0 through 9, both individually and as part of a larger string.
-
-```text
- _
- _|
-|_
-
-```
-
-Is converted to "2"
+The following input (without the comments) is converted to `"1234567890"`.
 
 ```text
       _  _     _  _  _  _  _  _  #
-    | _| _||_||_ |_   ||_||_|| | # decimal numbers.
+    | _| _||_||_ |_   ||_||_|| | # Decimal numbers.
     ||_  _|  | _||_|  ||_| _||_| #
-                                 # fourth line is always blank
+                                 # The fourth line is always blank,
 ```
 
-Is converted to "1234567890"
-
-## Step Four
+The following input is converted to `"123,456,789"`.
 
-Update your program to handle multiple numbers, one per line.
-When converting several lines, join the lines with commas.
+<!-- prettier-ignore-start -->
 
 ```text
-    _  _
+    _  _ 
   | _| _|
   ||_  _|
-
-    _  _
-|_||_ |_
+         
+    _  _ 
+|_||_ |_ 
   | _||_|
-
- _  _  _
+         
+ _  _  _ 
   ||_||_|
   ||_| _|
-
+         
 ```
 
-Is converted to "123,456,789".
+<!-- prettier-ignore-end -->
diff --git a/exercises/practice/ocr-numbers/.docs/introduction.md b/exercises/practice/ocr-numbers/.docs/introduction.md
new file mode 100644
index 00000000000..366d76062c7
--- /dev/null
+++ b/exercises/practice/ocr-numbers/.docs/introduction.md
@@ -0,0 +1,6 @@
+# Introduction
+
+Your best friend Marta recently landed their dream job working with a local history museum's collections.
+Knowing of your interests in programming, they confide in you about an issue at work for an upcoming exhibit on computing history.
+A local university's math department had donated several boxes of historical printouts, but given the poor condition of the documents, the decision has been made to digitize the text.
+However, the university's old printer had some quirks in how text was represented, and your friend could use your help to extract the data successfully.
diff --git a/exercises/practice/triangle/.docs/instructions.md b/exercises/practice/triangle/.docs/instructions.md
index 755cb8d19d3..e9b053dcd34 100644
--- a/exercises/practice/triangle/.docs/instructions.md
+++ b/exercises/practice/triangle/.docs/instructions.md
@@ -14,7 +14,8 @@ 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
-We opted to not include tests for degenerate triangles (triangles that violate these rules) to keep things simpler.
+_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.
 ~~~~
 

From a0c1db908af44cadf8771973124bd0063a1eca00 Mon Sep 17 00:00:00 2001
From: BethanyG <BethanyG@users.noreply.github.com>
Date: Tue, 30 Dec 2025 13:56:58 -0800
Subject: [PATCH 07/12] Synced tests to problem-specifications and regenerated
 test cases. (#4059)

Added new test cases from problem-specifications and regenerated test file.
---
 exercises/practice/flower-field/.meta/tests.toml     | 3 +++
 exercises/practice/flower-field/flower_field_test.py | 5 ++++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/exercises/practice/flower-field/.meta/tests.toml b/exercises/practice/flower-field/.meta/tests.toml
index c2b24fdaf5c..965ba8fd4d7 100644
--- a/exercises/practice/flower-field/.meta/tests.toml
+++ b/exercises/practice/flower-field/.meta/tests.toml
@@ -44,3 +44,6 @@ description = "cross"
 
 [dd9d4ca8-9e68-4f78-a677-a2a70fd7a7b8]
 description = "large garden"
+
+[6e4ac13a-3e43-4728-a2e3-3551d4b1a996]
+description = "multiple adjacent flowers"
diff --git a/exercises/practice/flower-field/flower_field_test.py b/exercises/practice/flower-field/flower_field_test.py
index 019f7357fdb..d0f1334cbfc 100644
--- a/exercises/practice/flower-field/flower_field_test.py
+++ b/exercises/practice/flower-field/flower_field_test.py
@@ -1,6 +1,6 @@
 # These tests are auto-generated with test data from:
 # https://github.com/exercism/problem-specifications/tree/main/exercises/flower-field/canonical-data.json
-# File last updated on 2025-06-25
+# File last updated on 2025-12-30
 
 import unittest
 
@@ -52,6 +52,9 @@ def test_large_garden(self):
             ["1*22*1", "12*322", " 123*2", "112*4*", "1*22*2", "111111"],
         )
 
+    def test_multiple_adjacent_flowers(self):
+        self.assertEqual(annotate([" ** "]), ["1**1"])
+
     # Additional tests for this track
     def test_annotate_9(self):
         self.assertEqual(

From e14ea7fb90db29b14eb321f067fe012a0c55c84b Mon Sep 17 00:00:00 2001
From: BethanyG <BethanyG@users.noreply.github.com>
Date: Tue, 30 Dec 2025 13:57:59 -0800
Subject: [PATCH 08/12] Updated tests.toml and regenerated isbn-verifier test
 cases. (#4060)

Added two new test cases from problem-specifications.
---
 exercises/practice/isbn-verifier/.meta/tests.toml      | 6 ++++++
 exercises/practice/isbn-verifier/isbn_verifier_test.py | 8 +++++++-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/exercises/practice/isbn-verifier/.meta/tests.toml b/exercises/practice/isbn-verifier/.meta/tests.toml
index 6d5a8459907..17e18d47ac5 100644
--- a/exercises/practice/isbn-verifier/.meta/tests.toml
+++ b/exercises/practice/isbn-verifier/.meta/tests.toml
@@ -30,6 +30,12 @@ description = "invalid character in isbn is not treated as zero"
 [28025280-2c39-4092-9719-f3234b89c627]
 description = "X is only valid as a check digit"
 
+[8005b57f-f194-44ee-88d2-a77ac4142591]
+description = "only one check digit is allowed"
+
+[fdb14c99-4cf8-43c5-b06d-eb1638eff343]
+description = "X is not substituted by the value 10"
+
 [f6294e61-7e79-46b3-977b-f48789a4945b]
 description = "valid isbn without separating dashes"
 
diff --git a/exercises/practice/isbn-verifier/isbn_verifier_test.py b/exercises/practice/isbn-verifier/isbn_verifier_test.py
index dbcddf19d48..5c9bf6f755a 100644
--- a/exercises/practice/isbn-verifier/isbn_verifier_test.py
+++ b/exercises/practice/isbn-verifier/isbn_verifier_test.py
@@ -1,6 +1,6 @@
 # These tests are auto-generated with test data from:
 # https://github.com/exercism/problem-specifications/tree/main/exercises/isbn-verifier/canonical-data.json
-# File last updated on 2023-07-19
+# File last updated on 2025-12-30
 
 import unittest
 
@@ -31,6 +31,12 @@ def test_invalid_character_in_isbn_is_not_treated_as_zero(self):
     def test_x_is_only_valid_as_a_check_digit(self):
         self.assertIs(is_valid("3-598-2X507-9"), False)
 
+    def test_only_one_check_digit_is_allowed(self):
+        self.assertIs(is_valid("3-598-21508-96"), False)
+
+    def test_x_is_not_substituted_by_the_value_10(self):
+        self.assertIs(is_valid("3-598-2X507-5"), False)
+
     def test_valid_isbn_without_separating_dashes(self):
         self.assertIs(is_valid("3598215088"), True)
 

From 0792f3e139854149767b6b54894a403e9b167063 Mon Sep 17 00:00:00 2001
From: BethanyG <BethanyG@users.noreply.github.com>
Date: Tue, 30 Dec 2025 13:59:14 -0800
Subject: [PATCH 09/12] Synced tests.toml and regenerated test cases. (#4061)

Added three new test cases from problem-specifications.
---
 exercises/practice/satellite/.meta/tests.toml | 22 +++++++-
 .../practice/satellite/satellite_test.py      | 55 ++++++++++++++++++-
 2 files changed, 73 insertions(+), 4 deletions(-)

diff --git a/exercises/practice/satellite/.meta/tests.toml b/exercises/practice/satellite/.meta/tests.toml
index 8314daa436f..d0ed5b6ac5a 100644
--- a/exercises/practice/satellite/.meta/tests.toml
+++ b/exercises/practice/satellite/.meta/tests.toml
@@ -1,6 +1,13 @@
-# This is an auto-generated file. Regular comments will be removed when this
-# file is regenerated. Regenerating will not touch any manually added keys,
-# so comments can be added in a "comment" key.
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
 
 [8df3fa26-811a-4165-9286-ff9ac0850d19]
 description = "Empty tree"
@@ -19,3 +26,12 @@ description = "Reject inconsistent traversals of same length"
 
 [d86a3d72-76a9-43b5-9d3a-e64cb1216035]
 description = "Reject traversals with repeated items"
+
+[af31ae02-7e5b-4452-a990-bccb3fca9148]
+description = "A degenerate binary tree"
+
+[ee54463d-a719-4aae-ade4-190d30ce7320]
+description = "Another degenerate binary tree"
+
+[87123c08-c155-4486-90a4-e2f75b0f3e8f]
+description = "Tree with many more items"
diff --git a/exercises/practice/satellite/satellite_test.py b/exercises/practice/satellite/satellite_test.py
index f44a5384798..6b960de73e3 100644
--- a/exercises/practice/satellite/satellite_test.py
+++ b/exercises/practice/satellite/satellite_test.py
@@ -1,6 +1,6 @@
 # These tests are auto-generated with test data from:
 # https://github.com/exercism/problem-specifications/tree/main/exercises/satellite/canonical-data.json
-# File last updated on 2023-07-19
+# File last updated on 2025-12-30
 
 import unittest
 
@@ -67,3 +67,56 @@ def test_reject_traversals_with_repeated_items(self):
             tree_from_traversals(preorder, inorder)
         self.assertEqual(type(err.exception), ValueError)
         self.assertEqual(err.exception.args[0], "traversals must contain unique items")
+
+    def test_a_degenerate_binary_tree(self):
+        preorder = ["a", "b", "c", "d"]
+        inorder = ["d", "c", "b", "a"]
+
+        expected = {
+            "v": "a",
+            "l": {
+                "v": "b",
+                "l": {"v": "c", "l": {"v": "d", "l": {}, "r": {}}, "r": {}},
+                "r": {},
+            },
+            "r": {},
+        }
+        self.assertEqual(tree_from_traversals(preorder, inorder), expected)
+
+    def test_another_degenerate_binary_tree(self):
+        preorder = ["a", "b", "c", "d"]
+        inorder = ["a", "b", "c", "d"]
+
+        expected = {
+            "v": "a",
+            "l": {},
+            "r": {
+                "v": "b",
+                "l": {},
+                "r": {"v": "c", "l": {}, "r": {"v": "d", "l": {}, "r": {}}},
+            },
+        }
+        self.assertEqual(tree_from_traversals(preorder, inorder), expected)
+
+    def test_tree_with_many_more_items(self):
+        preorder = ["a", "b", "d", "g", "h", "c", "e", "f", "i"]
+        inorder = ["g", "d", "h", "b", "a", "e", "c", "i", "f"]
+
+        expected = {
+            "v": "a",
+            "l": {
+                "v": "b",
+                "l": {
+                    "v": "d",
+                    "l": {"v": "g", "l": {}, "r": {}},
+                    "r": {"v": "h", "l": {}, "r": {}},
+                },
+                "r": {},
+            },
+            "r": {
+                "v": "c",
+                "l": {"v": "e", "l": {}, "r": {}},
+                "r": {"v": "f", "l": {"v": "i", "l": {}, "r": {}}, "r": {}},
+            },
+        }
+        self.assertEqual(tree_from_traversals(preorder, inorder), expected)

From 44a9bb75db4f419f1dde7163f3d9788f8009a165 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 1 Jan 2026 15:31:41 -0800
Subject: [PATCH 10/12] Bump actions/checkout from 6.0.0 to 6.0.1 (#4063)

Bumps [actions/checkout](https://github.com/actions/checkout) from 6.0.0 to 6.0.1.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/1af3b93b6815bc44a9784bd300feb67ff0d1eeb3...8e8c483db84b4bee98b60c0593521ed34d9990e8)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: 6.0.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci-workflow.yml     | 4 ++--
 .github/workflows/issue-commenter.yml | 2 +-
 .github/workflows/test-runner.yml     | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci-workflow.yml b/.github/workflows/ci-workflow.yml
index e853469c6d0..33f47f541e4 100644
--- a/.github/workflows/ci-workflow.yml
+++ b/.github/workflows/ci-workflow.yml
@@ -14,7 +14,7 @@ jobs:
   housekeeping:
     runs-on: ubuntu-24.04
     steps:
-    - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3
+    - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
 
     - name: Set up Python
       uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548
@@ -55,7 +55,7 @@ jobs:
       matrix:
         python-version: [3.7, 3.8, 3.9, 3.10.6, 3.11.2]
     steps:
-    - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3
+    - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
 
     - uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548
       with:
diff --git a/.github/workflows/issue-commenter.yml b/.github/workflows/issue-commenter.yml
index 4f6bff60471..9e3b678f66e 100644
--- a/.github/workflows/issue-commenter.yml
+++ b/.github/workflows/issue-commenter.yml
@@ -9,7 +9,7 @@ jobs:
     name: Comments for every NEW issue.
     steps:
       - name: Checkout
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
 
       - name: Read issue-comment.md
         id: issue-comment
diff --git a/.github/workflows/test-runner.yml b/.github/workflows/test-runner.yml
index 97fcf6e5be3..f32c41b958a 100644
--- a/.github/workflows/test-runner.yml
+++ b/.github/workflows/test-runner.yml
@@ -10,6 +10,6 @@ jobs:
   test-runner:
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
       - name: Run test-runner
         run: docker compose run test-runner

From b5d1682ad2cfd6e4f6b1d89a8bb40e6db2d083a2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 1 Jan 2026 15:32:06 -0800
Subject: [PATCH 11/12] Bump actions/stale from 10.1.0 to 10.1.1 (#4062)

Bumps [actions/stale](https://github.com/actions/stale) from 10.1.0 to 10.1.1.
- [Release notes](https://github.com/actions/stale/releases)
- [Changelog](https://github.com/actions/stale/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/stale/compare/5f858e3efba33a5ca4407a664cc011ad407f2008...997185467fa4f803885201cee163a9f38240193d)

---
updated-dependencies:
- dependency-name: actions/stale
  dependency-version: 10.1.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/stale.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
index 4a5a9a772f1..f40e8010052 100644
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@@ -8,7 +8,7 @@ jobs:
   stale:
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/stale@5f858e3efba33a5ca4407a664cc011ad407f2008
+      - uses: actions/stale@997185467fa4f803885201cee163a9f38240193d
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           days-before-stale: 21

From 608b96371f7c3744002268ef38d68cdf3911cf65 Mon Sep 17 00:00:00 2001
From: Colin Leach <colin.leach@comcast.net>
Date: Fri, 2 Jan 2026 13:52:27 -0700
Subject: [PATCH 12/12] Flower field approaches (#3935)

* [Flower Field] draft approaches doc

* minor edits

* Suggestions and edits for flower-field approaches intro doc.

* Add guidance on approach selection for 2D processing

Added a section discussing the choice of approach for processing a 2-dimensional board, emphasizing the trade-offs between readability and performance.

Honestly, I'm not sure what's best here, so please don't feel inhibited in hacking it about!

---------

Co-authored-by: Colin Leach <colin.ex@pm.me>
Co-authored-by: BethanyG <BethanyG@users.noreply.github.com>
---
 .../flower-field/.approaches/config.json      |   8 +
 .../flower-field/.approaches/introduction.md  | 272 ++++++++++++++++++
 2 files changed, 280 insertions(+)
 create mode 100644 exercises/practice/flower-field/.approaches/config.json
 create mode 100644 exercises/practice/flower-field/.approaches/introduction.md

diff --git a/exercises/practice/flower-field/.approaches/config.json b/exercises/practice/flower-field/.approaches/config.json
new file mode 100644
index 00000000000..cf5b9a7b872
--- /dev/null
+++ b/exercises/practice/flower-field/.approaches/config.json
@@ -0,0 +1,8 @@
+{
+  "introduction": {
+    "authors": [
+      "colinleach",
+      "BethanyG"
+    ]
+  }
+}
diff --git a/exercises/practice/flower-field/.approaches/introduction.md b/exercises/practice/flower-field/.approaches/introduction.md
new file mode 100644
index 00000000000..ab5e24840d2
--- /dev/null
+++ b/exercises/practice/flower-field/.approaches/introduction.md
@@ -0,0 +1,272 @@
+
+# Introduction
+
+The Flower Field exercise is designed to practice iteration, boolean logic and raising errors with error messages.
+It also provides ample opportunities for working with `lists`, `list-indexing`, `comprehensions`, `tuples`, and `generator-expressions`.
+
+
+## General considerations and guidance for the exercise
+
+It is possible (_and potentially easier_) to break the problem down into a series of sub-tasks, with plenty of scope to mix and match strategies within these sections:
+
+- Is the board valid?
+- Is the current square a flower?
+- What are the valid neighboring squares, and how many of them contain flowers?
+
+Core Python does not support matrices nor N-dimensional arrays, though these are at the heart of many third-party packages such as NumPy.
+Due to this limitation, the input board and final result for this exercise are implemented in the tests as a `list` of strings; one string per "row" of the board.
+
+
+Intermediate processing for the problem is likely to use lists of lists with a final `''.join()` for each "row" in the returned single `list`, although other strategies could be employed.
+Helpfully, Python considers both [lists][ordered-sequences] and [strings][text-sequences] as [sequence types][common-sequence-operations], and can iterate over/index into both in the same fashion.
+
+
+## Validating boards
+
+The "board" or "field" must be rectangular: essentially, all rows must be the same length as the first row.
+This means that any board can be invalidated using the built-ins `all()` or `any()` to check for equal lengths of the strings in the `list` (_see an example below_).
+
+Perhaps surprisingly, both row and column lengths **can be zero/empty**, so an apparently "non-existent board or field" is considered valid and needs special handling:
+
+
+```python
+    rows = len(garden)
+    if rows > 0:
+        cols = len(garden[0])
+    else:
+        return []
+        
+    if any([len(row) != cols for row in garden]):
+        raise ValueError('The board is invalid with current input.')
+```
+
+Additionally, the only valid entries for the board/field are a space `' '` (_position empty_) or an asterisk `'*'` (_flower in position_).
+ All other characters are _invalid_ and should `raise` an error with an appropriate error message.
+ The exercise [tests][flower-field-tests] check for specific error messages including punctuation, so should be read or copied carefully.
+
+Some solutions use regular expressions for these checks, but there are simpler (_and more performant_) options:
+
+
+```python
+    if garden[row][col] not in (' ', '*'):
+        # raise error
+```
+
+Depending on how the code is structured, it may be possible to combine the checks for row length with the checks for valid characters.
+More commonly, board/field dimensions are checked at the beginning.
+Invalid characters are then detected while iterating through the rows of the board/field.
+
+
+## Processing squares and finding occupied neighbors
+
+Squares containing a flower are straightforward: you can copy `'*'` to the corresponding square in the results `list`.
+
+Empty squares present a challenge: count how many flowers are in all the squares _adjacent_ to it.
+But *How many squares are adjacent to the current position?*
+In the middle of a reasonably large board there will be 8 adjacent squares, but this is reduced for squares at edges or corners.
+
+
+### Some square processing methods
+
+Note that we only want a _count_ of nearby flowers.
+Their precise _location_ is irrelevant.
+
+
+1. Nested `if..elif` statements
+
+   This can be made to work, but can quickly become very verbose or confusing if not thought out carefully:
+
+   ```python
+       for index_i, _ in enumerate(flowerfield):
+        temp_row = ""
+        for index_j in range(column_count):
+            if flowerfield[index_i][index_j].isspace():
+                temp_row += count_flowers(flowerfield, index_i, index_j)
+            elif flowerfield[index_i][index_j] == "*":
+                temp_row += "*"
+            else:
+                raise ValueError("The board is invalid with current input.")
+        flowerfield[index_i] = temp_row
+    ```
+
+2. Explicit coordinates
+
+   List all the possibilities then filter out any squares that fall outside the board:
+
+    ```python
+        def count_adjacent(row, col):
+            adj_squares = (
+                (row-1, col-1), (row-1, col), (row-1, col+1),
+                (row,   col-1),           (row,   col+1),
+                (row+1, col-1), (row+1, col), (row+1, col+1),
+            )
+    
+            # which are on the board?
+            neighbors = [garden[row][col] for row, col in adj_squares
+                         if 0 <= row < rows and 0 <= col < cols]
+            # how many contain flowers?
+            return len([adj for adj in neighbors if adj == '*'])
+    ```
+
+3. Using a comprehension or generator expression
+
+    ```python
+     # Using a list comprehension
+     squares = [(row + row_diff, col + col_diff) 
+                 for row_diff in (-1, 0, 1) 
+                 for col_diff in (-1, 0, 1)]
+      
+     # Using a generator expression       
+     squares = ((row + row_diff, col + col_diff) 
+                 for row_diff in (-1, 0, 1) 
+                 for col_diff in (-1, 0, 1))
+    ```
+
+     A key insight here is that we can work on a 3x3 block of cells: we already ensured that the central cell does *not* contain a flower that would affect our count.
+    We can then filter and count as in the `count_adjacent` function in the previous code.
+
+4.  Using complex numbers
+
+    ```python
+    def neighbors(cell):
+            """Yield all eight neighboring cells."""
+            for x in (-1, 0, 1):
+                for y in (-1, 0, 1):
+                    if offset := x + y * 1j:
+                        yield cell + offset
+    ```
+
+    A particularly elegant solution is to treat the board/field as a portion of the complex plane.
+    In Python, [complex numbers][complex-numbers] are a standard numeric type, alongside integers and floats.
+    *This is less widely known than it deserves to be.*
+
+    The constructor for a complex number is `complex(x, y)` or (as here) `x + y * 1j`, where `x` and `y` are the real and imaginary parts, respectively.
+
+    There are two properties of complex numbers that help us in this case:
+    - The real and imaginary parts act independently under addition.
+    - The value `complex(0, 0)` is the complex zero, which like integer zero is treated as False in Python conditionals.
+
+    A tuple of integers would not work as a substitute, because `+` behaves as the concatenation operator for tuples:
+
+    ```python
+    >>> complex(1, 2) + complex(3, 4)
+    (4+6j)
+    >>> (1, 2) + (3, 4)
+    (1, 2, 3, 4)
+    ```
+
+    Note also the use of the ["walrus" operator][walrus-operator] `:=` in the definition of `offset` above.
+    This relatively recent addition to Python simplifies variable assignment within the limited scope of an if statement or a comprehension.
+
+
+## Ways of putting it all together
+
+The example below takes an object-oriented approach using complex numbers, included because it is a particularly clear illustration of the various topics discussed above.
+
+All validation checks are done in the object constructor.
+
+```python
+"""Flower Field."""
+
+def neighbors(cell):
+    """Yield all eight neighboring cells."""
+    for x in (-1, 0, 1):
+        for y in (-1, 0, 1):
+            if offset := x + y * 1j:
+                yield cell + offset
+
+
+class Garden:
+    """garden helper."""
+
+    def __init__(self, data):
+        """Initialize."""
+        self.height = len(data)
+        self.width = len(data[0]) if data else 0
+
+        if not all(len(row) == self.width for row in data):
+            raise ValueError("The board is invalid with current input.")
+
+        self.data = {}
+        for y, line in enumerate(data):
+            for x, val in enumerate(line):
+                self.data[x + y * 1j] = val
+        if not all(v in (" ", "*") for v in self.data.values()):
+            raise ValueError("The board is invalid with current input.")
+
+    def val(self, x, y):
+        """Return the value for one square."""
+        cur = x + y * 1j
+        if self.data[cur] == "*":
+            return "*"
+        count = sum(self.data.get(neighbor, "") == "*" for neighbor in neighbors(cur))
+        return str(count) if count else " "
+
+    def convert(self):
+        """Convert the garden."""
+        return ["".join(self.val(x, y) 
+                for x in range(self.width))
+                for y in range(self.height)]
+
+
+def annotate(garden):
+    """Annotate a garden."""
+    return Garden(garden).convert()
+```
+
+The example below takes an opposite strategy, using a single function, `list comprehensions`, and nested `if-elif` statements":
+
+```python
+def annotate(garden):
+    grid = [[0 for _ in row] for row in garden]
+    positions = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
+
+    for col, row in enumerate(garden):
+        # Checking that the board/field is rectangular up front.
+        if len(row) != len(grid[0]):
+            raise ValueError("The board is invalid with current input.")
+        
+        # Validating square content.
+        for index, square in enumerate(row):
+            if square == " ": 
+                continue
+            elif square != "*":
+                raise ValueError("The board is invalid with current input.")
+            grid[col][index] = "*"
+            
+            for dr, dc in positions:
+                dr += col
+                if dr < 0 or dr >= len(grid):
+                    continue
+                
+                dc += index
+                if dc < 0 or dc >= len(grid[dr]):
+                    continue
+                
+                if grid[dr][dc] != "*":
+                    grid[dr][dc] += 1
+                
+    return ["".join(" " if square == 0 else str(square) for square in row) for row in grid]
+```
+
+## Which approach to use?
+
+Processing a 2-dimensional board inevitably means using some form of nested loops, which is likely to dominate performance.
+
+Using comprehensions and/or generators instead of explicit loops may offer a slight speed-up, as well as more concise code.
+However, performance differences are probably small, and the concise syntax _may_ be less easy to read.
+
+In this case, readability is probably more important than aggressive optimization.
+So, we need to understand the target audience, and how they perceive "readability".
+
+Python experts find comprehensions very idiomatic (and generators, which have similar syntax), but programmers with a different language background can get confused.
+
+Complex numbers are a more extreme case: wonderfully clear and elegant for people with a suitable mathematical background, potentially mystifying for the wider population.
+Tastes differ!
+
+[common-sequence-operations]: https://docs.python.org/3.13/library/stdtypes.html#common-sequence-operations
+[complex-numbers]: https://exercism.org/tracks/python/concepts/complex-numbers
+[flower-field-tests]: https://github.com/exercism/python/blob/main/exercises/practice/flower-field/flower_field_test.py
+[ordered-sequences]: https://docs.python.org/3.13/library/stdtypes.html#sequence-types-list-tuple-range
+[text-sequences]: https://docs.python.org/3.13/library/stdtypes.html#text-sequence-type-str
+[walrus-operator]: https://peps.python.org/pep-0572/