Updated formating

Author: meatball133

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

@@ -33,7 +33,6 @@ The result string is returned once the loop finishes.
 
 If only English letters are needed, the constant [`string.ascii_lowercase`][ascii_lowercase] can be imported from the [`string`][string] module.
 
-
 ```python
 from string import ascii_lowercase
 

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

@@ -22,15 +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].
@@ -41,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 2_) 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

@@ -3,7 +3,6 @@
 There are various ways to solve `rotational-cipher`.
 You can for example use [ascii values][ascii], an alphabet `str` or `list`, recursion, or `str.translate`.
 
-
 ## General guidance
 
 The goal of this exercise is to shift the letters in a string by a given integer key between 0 and 26.
@@ -15,16 +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):
@@ -42,7 +39,6 @@ def rotate(text, key):
 
 For more information, check the [ascii values approach][approach-ascii-values].
 
-
 ## Approach: Alphabet
 
 This approach is similar to the ascii one, but it uses the index number of each letter in an alphabet string.
@@ -53,7 +49,6 @@ The big advantage of this approach is the ability to use any alphabet (_although
 Here, if we want to use the scandinavian letter: **å**, we can simply insert it into our string where we want it:
 `abcdefghijklmnopqrstuvwxyzå` and the rotation will work correctly.
 
-
 ```python
 # This only uses English characters
 AlPHABET = "abcdefghijklmnopqrstuvwxyz"
@@ -73,16 +68,14 @@ def rotate(text, key):
 
 For more information, check the [Alphabet approach][approach-alphabet].
 
-
 ## Approach: Str translate
 
 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
@@ -94,19 +87,16 @@ def rotate(text, key):
 
 For more information, check the [Str translate approach][approach-str-translate].
 
-
 ## Approach: Recursion
 
 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"
@@ -126,7 +116,6 @@ def rotate(text, key):
 
 For more information, check the [Recursion approach][approach-recursion].
 
-
 ## Benchmark
 
 For more information, check the [Performance article][article-performance].

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

@@ -28,13 +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

exercises/practice/rotational-cipher/.approaches/str-translate/content.md

@@ -30,13 +30,12 @@ The second argument is the `translator` variable + uppercase `translator` variab
 
 `makestrans` does is that it takes the [Unicode][unicode] values of the first argument and maps them to the corresponding Unicode values in the second argument, creating a `dict`.
 
-
 ```python
 >>> str.maketrans("abc", "def")
 {97: 100, 98: 101, 99: 102}
 ```
 
-`str.translate` takes the `dict` created by `str.makestrans`  and uses it to translate the characters in the `text` argument.
+`str.translate` takes the `dict` created by `str.makestrans` and uses it to translate the characters in the `text` argument.
 
 ```python
 >>> "abc".translate({97: 100, 98: 101, 99: 102})

exercises/practice/rotational-cipher/.articles/performance/content.md

@@ -30,7 +30,7 @@ rotate recursion short : 5.4000120144337416e-06
 ## Conclusion
 
 For a long string as input, the `str.translate` approach the fastest, followed by ascii, alphabet, and finally recursion.
-For a short string as input, is the alphabet approach the is the fastest, followed by ascii, recursion and finally  `str.translate`.
+For a short string as input, is the alphabet approach the is the fastest, followed by ascii, recursion and finally `str.translate`.
 
 This means that if you know the input is a short string, the fastest approach is to use the alphabet, and forgo the overhead of making and saving a translation dictionary.
 On the other hand, if the input is a long string, the overhead of making a dictionary is amortized over the length of the text to be translated, and the fastest approach becomes `str.translate`.