Convert backtick (`) admonition fences to tildes (~). (#2495)

Author: ErikSchierboom

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-array/content.md

@@ -33,10 +33,10 @@ The correct answer is selected from the array by using the score as the array in
 The `String` [`trim()`][trim] method is applied to the input to eliminate any whitespace at either end of the input.
 If the string has no characters left, it returns the response for saying nothing.
 
-```exercism/caution
+~~~~exercism/caution
 Note that a `null` `string` would be different from a `String` of all whitespace.
 A `null` `String` would throw a `NullPointerException` if `trim()` were applied to it.
-```
+~~~~
 
 A [Pattern][pattern] is defined to look for at least one English alphabetic character.
 

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

@@ -40,10 +40,10 @@ Execution will either return or will continue to the next statement anyway.
 The `String` [`trim()`][trim] method is applied to the input to eliminate any whitespace at either end of the input.
 If the string has no characters left, it returns the response for saying nothing.
 
-```exercism/caution
+~~~~exercism/caution
 Note that a `null` `string` would be different from a `String` of all whitespace.
 A `null` `String` would throw a `NullPointerException` if `trim()` were applied to it.
-```
+~~~~
 
 A [Pattern][pattern] is defined to look for at least one English alphabetic character.
 

exercises/practice/collatz-conjecture/.approaches/intstream-iterate/content.md

@@ -27,12 +27,12 @@ Another lambda is used to process the input number.
 [Bitwise operators][bitwise-operators] are used to check if the number is odd and to divide it in half if it is even.
 The bitwise AND operator (`&`) compares the number with `1` to see if it is odd.
 
-```exercism/note
+~~~~exercism/note
 Another way to go about checking if the number is even or odd is to see if it is evenly divided by `2`
 by using the [modulo (also know as the remainder) operator](https://www.geeksforgeeks.org/modulo-or-remainder-operator-in-java/).
 So, to see if it is even we could use `start % 2 == 0`.
 That might be slightly less performant but perhaps more readable for intent, especially for those who don't "speak binary".
-```
+~~~~
 
 If the number is even, then the right shift operator (`>>`) shifts all of the bits once to the right, which is the equivalent
 of dividing the number by `2`.

exercises/practice/collatz-conjecture/.approaches/while-loop/content.md

@@ -30,12 +30,12 @@ If the number is already `1` before control flow gets to the `while` loop, then
 [Bitwise operators][bitwise-operators] are used to check if the number is odd and to divide it in half if it is even.
 The bitwise AND operator (`&`) compares the number with `1` to see if it is odd.
 
-```exercism/note
+~~~~exercism/note
 Another way to go about checking if the number is even or odd is to see if it is evenly divided by `2`
 by using the [modulo (also know as the remainder) operator](https://www.geeksforgeeks.org/modulo-or-remainder-operator-in-java/).
 So, to see if it is even we could use `if (start % 2 == 0)`.
 That might be slightly less performant but perhaps more readable for intent, especially for those who don't "speak binary".
-```
+~~~~
 
 If the number is even, then the right shift equals operator (`>>=`) shifts all of the bits once to the right, which is the equivalent
 of dividing the number by `2`.

exercises/practice/darts/.approaches/doublepredicate/content.md

@@ -33,22 +33,22 @@ Then the radius of the dart throw is calculated and assigned to a variable.
 A `DoublePredicate` is defined as a [lambda][lambda] that takes in a `double` value that represents the ring radius
 and compares it with the dart throw radius.
 
-```exercism/note
+~~~~exercism/note
 Although the dart throw radius is not directly passed to the lambda, the lambda can use it.
 To do so is called [capturing](https://www.geeksforgeeks.org/java-lambda-expression-variable-capturing-with-examples/) the variable.
 To capture a variable, it must be in the enclosing [scope](https://www.geeksforgeeks.org/variable-scope-in-java/)
 of the lambda, and it must be effectively `final`,
 meaning that is is not changed in the course of the program.
-```
+~~~~
 
-```exercism/note
+~~~~exercism/note
 The reason `DoublePredicate` is used instead of `Predicate<Double>` is to avoid the
 [autoboxing](https://docs.oracle.com/javase/tutorial/java/data/autoboxing.html)
 that `Predicate<Double>` would do.
 `DoublePredicate` handles its primitive `double` argument without boxing it.
 This is also why the lambda is required to be given a specific target type instead of `var`,
 since the same lambda could be used for either `DoublePredicate` or `Predicate<Double>`.
-```
+~~~~
 
 A series of calls to the `DoublePredicate` is then made.
 

exercises/practice/difference-of-squares/.approaches/intstream/content.md

@@ -24,12 +24,12 @@ class DifferenceOfSquaresCalculator {
 
 This solution iterates using the [`rangeClosed()`][rangeclosed] method of the [`IntStream`][intstream] class.
 
-```exercism/note
+~~~~exercism/note
 The difference between `rangeClosed()` and [`range()`](https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html#range-int-int-)
 is that the ending bound is _inclusive_ for `rangeClosed()` and _exclusive_ for `range()`.
 So, `IntStream.range(1, 10)` iterates from `1` up to but not including `10`,
 and `IntStream.rangeClosed(1, 10)` iterates from `1` through `10`.
-```
+~~~~
 
 In `computeSquareOfSumTo`, the numbers are added with the [`sum()`][sum] method.
 The sum of the numbers is then multiplied by itself to get the square of the summed numbers.

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/isbn-verifier/.approaches/chars-foreach/content.md

@@ -51,12 +51,12 @@ If so, it gets the digit value of the codepoint by subtracting the [ASCII][ascii
 So, if the codepoint is a `0`, then subtracting the ASCII value of `0` from itself results in `0`.
 If the codepoint is a `1`, then subtracting the ASCII value of `0` from the ASCII value of `1` results in `1`, and so on.
 
-```exercism/note/
+~~~~exercism/note/
 Another way to convert the codepoint to a digit is to use the built-in
 [`Character.digit()`](https://docs.oracle.com/javase/7/docs/api/java/lang/Character.html#digit(char,%20int))
 method, which also works for [Unicode](https://docs.oracle.com/javase/tutorial/i18n/text/unicode.html) codepoints.
 Since for this exercise all of the codepoints are ASCII, simple ASCII math will do. 
-```
+~~~~
 
 The digit is multiplied by 10 minus the position, with the position starting at `0`.
 So, for the position furthest to the left, the digit is multiplied by `10 - 0` (`10`).