Added back tilda

Author: meatball133

exercises/practice/rotational-cipher/.approaches/ascii-values/content.md

@@ -22,14 +22,14 @@ It uses numbers to represent 128 different entities including carriage returns,
 In ascii, all the lowercase English letters appear between 97 and 123.
 While the uppercase letters are in the range between 65 and 91.
 
-```exercism/caution
+~~~~exercism/caution
 
 This approach only supports the English alphabet.
 Non-English alphabets are not contiguous in their ascii number ranges, and are not consistently defined across platforms.
 For example, the Scandinavian letter: **å** has the extended ascii value of 132, but is used in combination with Latin characters that appear in the 65-91 and 97-123 ranges.
 This means that a shift for an extended ascii word containing **å** won't result in an accurate alphabet position for a Scandinavian language.
 
-```
+~~~~
 
 The approach starts with defining the function `rotate()`, with a variable `result` is assigned to an empty string.
 The elements of the text argument are then iterated over using a [`for loop`][for-loop].
@@ -40,7 +40,7 @@ Unicode's first 128 code points have the same numbers as their ascii counterpart
 
 If the element is an uppercase letter, [`ord`][ord] is used to convert the letter to an integer.
 The integer is added to the numeric key and then 65 is subtracted from the total.
-Finally, the result is [modulo (`%`)][modulo] 26 (_to put the value within the 2_) and 65 is added back.
+Finally, the result is [modulo (%)][modulo] 26 (_to put the value within the 0-26 range_) and 65 is added back.
 
 This is because we want to know which letter of the alphabet the number will become.
 And if the new number is over 26 we want to make sure that it "wraps around" to remain in the range of 0-26.

exercises/practice/rotational-cipher/.approaches/introduction.md

@@ -14,14 +14,14 @@ This approach is straightforward to understand.
 It uses the ascii value of the letters to rotate them within the message.
 The numbers 65-91 in the ascii range represent lowercase Latin letters, while 97-123 represent uppercase Latin letters.
 
-```exercism/caution
+~~~~exercism/caution
 
 This approach only supports the English alphabet.
 Non-English alphabets are not contiguous in their ascii number ranges, and are not consistently defined across platforms.
 For example, the Scandinavian letter: **å** has the extended ascii value of 132, but is used in combination with Latin characters that appear in the 65-91 and 97-123 ranges.
 This means that a shift for an extended ascii word containing **å** won't result in an accurate alphabet position for a Scandinavian language.
 
-```
+~~~~
 
 ```python
 def rotate(text, key):
@@ -73,9 +73,9 @@ For more information, check the [Alphabet approach][approach-alphabet].
 This approach uses the [`str.translate`][str-translate] method to create a mapping from input to shifted string instead of using the index of an alphabet string to calculate the shift.
 The benefit of this approach is that it has no visible loop, making the code more concise.
 
-```exercism/note
+~~~~exercism/note
 `str.translate` **still loops over the `string`**  even if it is not visibly doing so.
-```
+~~~~
 
 ```python
 AlPHABET = "abcdefghijklmnopqrstuvwxyz
@@ -93,10 +93,10 @@ This approach uses a recursive function.
 A recursive function is a function that calls itself.
 This approach can be more concise than other approaches, and may also be more readable for some audiences.
 
-```exercism/caution
+~~~~exercism/caution
 Python does not have any tail-call optimization and has a default [recursion limit][recursion-limit] of 1000 calls on the stack.
 Calculate your base case carefully to avoid errors.
-```
+~~~~
 
 ```python
 AlPHABET = "abcdefghijklmnopqrstuvwxyz"

exercises/practice/rotational-cipher/.approaches/recursion/content.md

@@ -28,12 +28,12 @@ Then the `rotate` function can execute the same code again with new values.
 We can build a long chain or "stack" of `<letter> + rotate(rest)` calls until the `rest` variable is exhausted and the code adds `""`.
 That translates to something like this: `<letter> + <letter> + <letter> + <letter> + ""`.
 
-```exercism/note
+~~~~exercism/note
 By default, we can't have a function call itself more than 1000 times.
 Code that exceeds this recursion limit will throw a RecursionError.
 While it is possible to adjust the recursion limit, doing so risks crashing Python and may also crash your system.
 Casually raising the recursion limit is not recommended.
-```
+~~~~
 
 [clojure]: https://exercism.org/tracks/clojure
 [elixir]: https://exercism.org/tracks/elixir