Convert backtick (`) admonition fences to tildes (~) (#3509)

* Convert backtick (`) admonition fences to tildes (~).
* Updated Grains Test file to Fix CI
[no important files changed]
---------

Co-authored-by: BethanyG <[email protected]>

Author: ErikSchierboom

concepts/generators/about.md

@@ -94,9 +94,9 @@ When `yield` is evaluated, it pauses the execution of the enclosing function and
 
 The function then _stays in scope_, and when `__next__()` is called, execution resumes until `yield` is encountered again.
 
-```exercism/note
+~~~~exercism/note
 Using `yield` expressions is prohibited outside of functions.
-```
+~~~~
 
 ```python
 >>> def infinite_sequence():

exercises/concept/plane-tickets/.docs/introduction.md

@@ -94,9 +94,9 @@ When `yield` is evaluated, it pauses the execution of the enclosing function and
 
 The function then _stays in scope_, and when `__next__()` is called, execution resumes until `yield` is encountered again.
 
-```exercism/note
+~~~~exercism/note
 Using `yield` expressions is prohibited outside of functions.
-```
+~~~~
 
 ```python
 >>> def infinite_sequence():

exercises/practice/binary-search/.docs/instructions.md

@@ -5,9 +5,9 @@ Your task is to implement a binary search algorithm.
 A binary search algorithm finds an item in a list by repeatedly splitting it in half, only keeping the half which contains the item we're looking for.
 It allows us to quickly narrow down the possible locations of our item until we find it, or until we've eliminated all possible locations.
 
-```exercism/caution
+~~~~exercism/caution
 Binary search only works when a list has been sorted.
-```
+~~~~
 
 The algorithm looks like this:
 

exercises/practice/bob/.approaches/answer-list/content.md

@@ -22,12 +22,12 @@ Python doesn't _enforce_ having real constant values,
 but the `ANSWERS` list 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.
 
-```exercism/note
+~~~~exercism/note
 `ANSWERS` could prevent item reassignment by being defined as a [tuple](https://realpython.com/python-lists-tuples/#python-tuples) instead of a list.
 The items in a tuple cannot be changed, and the performance between a tuple and a list here is equivalent.
 The entire `ANSWERS` tuple could still be reassigned to another tuple,
 so uppercase letters would still be used to indicate that the `ANSWERS` tuple should not be changed.
-```
+~~~~
 
 The [`rstrip`][rstrip] method is applied to the input to eliminate any whitespace at the end of the input.
 If the input has no characters left, it uses the [falsiness][falsiness] of an empty string with the [`not`][not] operator to return the response for saying nothing.
@@ -37,11 +37,11 @@ A [ternary operator][ternary] is used for determining the score for a shout and
 
 The [`isupper`][isupper] method is used to test that there is at least one cased character and that all cased characters are uppercase.
 
-```exercism/note
+~~~~exercism/note
 A cased character is one which differs between lowercase and uppercase.
 For example, `?` and `3` are not cased characters, as they do not change between lowercase and uppercase.
 `a` and `z` are cased characters, since their lowercase form changes to `A` and ` Z` when uppercase.
-```
+~~~~
 
 If `isupper` is `True`, then `is_shout` is given the value of `2`; otherwise, it is given the value of `0`.
 

exercises/practice/bob/.approaches/if-statements-nested/content.md

@@ -20,23 +20,23 @@ def response(hey_bob):
 In this approach you have a series of `if` statements using the calculated variables to evaluate the conditions, some of which are nested.
 As soon as a `True` condition is found, the correct response is returned.
 
-```exercism/note
+~~~~exercism/note
 Note that there are no `elif` or `else` statements.
 If an `if` statement can return, then an `elif` or `else` is not needed.
 Execution will either return or will continue to the next statement anyway.
-```
+~~~~
 
 The [`rstrip`][rstrip] method is applied to the input to eliminate any whitespace at the end of the input.
 If the input has no characters left, it uses the [falsiness][falsiness] of an empty string with the [`not`][not] operator to return the response for saying nothing.
 Since it doesn't matter if there is leading whitespace, the `rstrip` function is used instead of [`strip`][strip].
 
 The [`isupper`][isupper] method is used to test that there is at least one cased character and that all cased characters are uppercase.
 
-```exercism/note
+~~~~exercism/note
 A cased character is one which differs between lowercase and uppercase.
 For example, `?` and `3` are not cased characters, as they do not change between lowercase and uppercase.
 `a` and `z` are cased characters, since their lowercase form changes to `A` and ` Z` when uppercase.
-```
+~~~~
 
 The [`endswith`][endswith] method is used to determine if the input ends with a question mark.
 

exercises/practice/bob/.approaches/if-statements/content.md

@@ -20,23 +20,23 @@ def response(hey_bob):
 In this approach you have a series of `if` statements using the calculated variables to evaluate the conditions.
 As soon as a `True` condition is found, the correct response is returned.
 
-```exercism/note
+~~~~exercism/note
 Note that there are no `elif` or `else` statements.
 If an `if` statement can return, then an `elif` or `else` is not needed.
 Execution will either return or will continue to the next statement anyway.
-```
+~~~~
 
 The [`rstrip`][rstrip] method is applied to the input to eliminate any whitespace at the end of the input.
 If the input has no characters left, it uses the [falsiness][falsiness] of an empty string with the [`not`][not] operator to return the response for saying nothing.
 Since it doesn't matter if there is leading whitespace, the `rstrip` function is used instead of [`strip`][strip].
 
 The [`isupper`][isupper] method is used to test that there is at least one cased character and that all cased characters are uppercase.
 
-```exercism/note
+~~~~exercism/note
 A cased character is one which differs between lowercase and uppercase.
 For example, `?` and `3` are not cased characters, as they do not change between lowercase and uppercase.
 `a` and `z` are cased characters, since their lowercase form changes to `A` and ` Z` when uppercase.
-```
+~~~~
 
 The [`endswith`][endswith] method is used to determine if the input ends with a question mark.
 

exercises/practice/etl/.docs/instructions.md

@@ -22,6 +22,6 @@ This needs to be changed to store each individual letter with its score in a one
 
 As part of this change, the team has also decided to change the letters to be lower-case rather than upper-case.
 
-```exercism/note
+~~~~exercism/note
 If you want to look at how the data was previously structured and how it needs to change, take a look at the examples in the test suite.
-```
+~~~~

exercises/practice/gigasecond/.docs/introduction.md

@@ -13,12 +13,12 @@ Then we can use metric system prefixes for writing large numbers of seconds in m
 - Perhaps you and your family would travel to somewhere exotic for two megaseconds (that's two million seconds).
 - And if you and your spouse were married for _a thousand million_ seconds, you would celebrate your one gigasecond anniversary.
 
-```exercism/note
+~~~~exercism/note
 If we ever colonize Mars or some other planet, measuring time is going to get even messier.
 If someone says "year" do they mean a year on Earth or a year on Mars?
 
 The idea for this exercise came from the science fiction novel ["A Deepness in the Sky"][vinge-novel] by author Vernor Vinge.
 In it the author uses the metric system as the basis for time measurements.
 
 [vinge-novel]: https://www.tor.com/2017/08/03/science-fiction-with-something-for-everyone-a-deepness-in-the-sky-by-vernor-vinge/
-```
+~~~~

exercises/practice/grains/grains_test.py

@@ -1,6 +1,6 @@
 # These tests are auto-generated with test data from:
 # https://github.com/exercism/problem-specifications/tree/main/exercises/grains/canonical-data.json
-# File last updated on 2023-07-19
+# File last updated on 2023-09-27
 
 import unittest
 
@@ -32,19 +32,19 @@ def test_grains_on_square_32(self):
     def test_grains_on_square_64(self):
         self.assertEqual(square(64), 9223372036854775808)
 
-    def test_square_0_raises_an_exception(self):
+    def test_square_0_is_invalid(self):
         with self.assertRaises(ValueError) as err:
             square(0)
         self.assertEqual(type(err.exception), ValueError)
         self.assertEqual(err.exception.args[0], "square must be between 1 and 64")
 
-    def test_negative_square_raises_an_exception(self):
+    def test_negative_square_is_invalid(self):
         with self.assertRaises(ValueError) as err:
             square(-1)
         self.assertEqual(type(err.exception), ValueError)
         self.assertEqual(err.exception.args[0], "square must be between 1 and 64")
 
-    def test_square_greater_than_64_raises_an_exception(self):
+    def test_square_greater_than_64_is_invalid(self):
         with self.assertRaises(ValueError) as err:
             square(65)
         self.assertEqual(type(err.exception), ValueError)

exercises/practice/isogram/.approaches/scrub-regex/content.md

@@ -12,9 +12,9 @@ def is_isogram(phrase):
 
 For this approach, [regular expression][regex], also known as a [regex][regex-how-to], is used to scrub the input phrase [str][str]ing.
 - In the pattern of `[^a-zA-Z]` the brackets are used to define a character set that looks for characters which are _not_ `a` through `z` and `A` through `Z`.
-```exercism/note
+~~~~exercism/note
 If the first character of a character set is `^`, all the characters that are _not_ in the rest of the character set will be matched.
-```
+~~~~
 This essentially matches any characters which are not in the English alphabet.
  The pattern is passed to the [`compile()`][compile] method to construct a [regular expression object][regex-object].
 - The [`sub()`][sub] method is then called on the regex object.