more backtick formatting fixes

Author: Yrahcaz7

exercises/practice/reverse-string/.approaches/additional-approaches/content.md

@@ -36,7 +36,7 @@ def reverse(text):
 This strategy encodes the string into a UTF-8 [`bytearray`][bytearray].
 It then uses a `while` loop to iterate through the text, calculating the length of a sequence (or 'window') to slice from `given` and prepend to `output`.
 The `index` counter is then incremented by the length of the 'window'.
-Once the `index` is greater than the length of `given`, the `output` `bytearray` is decoded into a UTF-8 string and returned.
+Once the `index` is greater than the length of `given`, the `output` bytearray is decoded into a UTF-8 string and returned.
 This is (_almost_) the same set of operations as described in the next approach, but operating on bytes in a `bytearray`, as opposed to text/codepoints in a `list` — although this strategy does not use `list.pop()` (_`bytearray` objects do not have a pop method_).
 
 This uses `O(n)` space for the output array.
@@ -56,14 +56,14 @@ def reverse(text):
     return "".join(output)
 ```
 
-This strategy uses two lists.
+This strategy uses two `list`s.
 One `list` for the codepoints in the text, and one to hold the codepoints in reverse order.
-First, the input text is turned into the `codepoints` `list`, and iterated over.
-Each codepoint is `pop()`ped from `codepoints` and appended to the `output` `list`.
+First, the input text is turned into the `codepoints` list, and iterated over.
+Each codepoint is `pop()`ped from `codepoints` and appended to the `output` list.
 Finally, `output` is joined via `str.join()` to create the reversed string.
 
-While this is a straightforward and readable approach, it creates both memory and performance overhead, due to the creation of the lists and the use of `str.join()`.
-This is much faster than the bytearray strategy or using string concatenation, but is still slightly slower than the slicing strategy.
+While this is a straightforward and readable approach, it creates both memory and performance overhead, due to the creation of the `list`s and the use of `str.join()`.
+This is much faster than the `bytearray` strategy or using string concatenation, but is still slightly slower than the slicing strategy.
 It also takes up `O(n)` auxiliary space with the `output` list.
 
 
@@ -134,8 +134,8 @@ As a (very) rough comparison, below is a timing table for these functions vs the
 | reverse bytes          | 1.92e-06 | 3.82e-06 | 7.36e-06 | 1.65e-05 | 2.17e-05 | 2.71e-05 | 4.47e-05 | 5.17e-04 | 6.10e-03 | 2.16e-01 |
 
 
-As you can see, the reverse using two lists and the reverse using a bytearray are orders of magnitude slower than using a reverse slice.
-For the largest inputs measured, the dual list solution was almost 55x slower, and the bytearray solution was almost 1800x slower.
+As you can see, the reverse using two lists and the reverse using a `bytearray` are orders of magnitude slower than using a reverse slice.
+For the largest inputs measured, the dual list solution was almost 55x slower, and the `bytearray` solution was almost 1800x slower.
 Timings for strings over 142 characters could not be run for the recursive strategy, due to Python's 1000 call recursion limit.
 
 

exercises/practice/reverse-string/.approaches/built-in-list-reverse/content.md

@@ -10,7 +10,7 @@ def reverse(text):
 
 These approaches start with turning the text into a `list` of codepoints.
 Rather than use a loop and `list.append()` to then reverse the text, the [`list.reverse()`][list-reverse-method] method is used to perform an in-place reversal.
-`str.join()` is then used to turn the list into a string.
+`str.join()` is then used to turn the `list` into a string.
 
 This takes `O(n)` time complexity because `list.reverse()` and `str.join()` iterate through the entire `list`.
 It uses `O(n)` space for the output `list`.
@@ -28,7 +28,7 @@ def reverse(text):
     return "".join(output)
 ```
 
-This variation is essentially the same as the solution above, but makes a codepoints list to keep the original codepoint ordering of the input text.
+This variation is essentially the same as the solution above, but makes a codepoints `list` to keep the original codepoint ordering of the input text.
 This does add some time and space overhead.
 
 
@@ -57,8 +57,8 @@ Calling the constructor is also quite a bit faster than using a "written out" `f
 
 As a (very) rough comparison, below is a timing table for these functions vs the canonical reverse slice:
 
-As you can see, using `list.reverse()` after converting the input text to a list is much slower than using a reverse slice.
-Iterating in a loop to create the output list also adds even more time.
+As you can see, using `list.reverse()` after converting the input text to a `list` is much slower than using a reverse slice.
+Iterating in a loop to create the output `list` also adds even more time.
 
 
 | **string length >>>>** |     5    |    11    |    22    |    52    |    66    |    86    |    142   |   1420   |   14200  |  142000  |

exercises/practice/reverse-string/.approaches/built-in-reversed/content.md

@@ -18,7 +18,7 @@ def reverse(text):
 ```
 
 This version uses `reversed()` to reverse a `range()` object rather than feed a `start`/`stop`/`step` to `range()` itself.
-It then uses the reverse range to iterate over the input string and concatenate each code point to a new `output` string.
+It then uses the reverse `range` to iterate over the input string and concatenate each code point to a new `output` string.
 This has over-complicated `reversed()`, as it can be called directly on the input string with almost no overhead.
 This has also incurs the performance hit of repeated concatenation to the `output` string.
 

exercises/practice/reverse-string/.approaches/introduction.md

@@ -14,8 +14,8 @@ In this introduction, we cover six general approaches and an additional group of
 1. Sequence Slice with Negative Step
 2. Iteration with String Concatenation
 3. Reverse Iteration with `range()`
-4. Make a list and Use `str.join()`
-5. Make a list and use `list.reverse()`
+4. Make a `list` and Use `str.join()`
+5. Make a `list` and use `list.reverse()`
 6. Use the built-in `reversed()`
 7. Other [interesting approaches][approach-additional-approaches]
 
@@ -72,7 +72,7 @@ This is essentially the same technique as the approach above, but incurs slightl
 
 For very long strings, this approach will still degrade to `O(n**2)` performance, due to the use of string concatenation.
 Using `str.join()` here can avoid the concatenation penalty.
-For more information and relative performance timings for this group, check out the [backwards iteration with range][approach-backward-iteration-with-range] approach.
+For more information and relative performance timings for this group, check out the [backwards iteration with `range()`][approach-backward-iteration-with-range] approach.
 
 
 ## Approach: Create a `list` and Use `str.join()` to make new String
@@ -87,8 +87,8 @@ def reverse(text):
     return "".join(output)
 ```
 
-This approach either breaks the string up into a list of codepoints to swap or creates an empty list as a "parking place" to insert or append codepoints.
-It then iterates over the text, swapping, inserting, or appending each codepoint to the output list.
+This approach either breaks the string up into a `list` of codepoints to swap or creates an empty `list` as a "parking place" to insert or append codepoints.
+It then iterates over the text, swapping, inserting, or appending each codepoint to the output `list`.
 Finally, `str.join()` is used to re-assemble the `list` into a string.
 
 For more variations and relative performance timings for this group, check out the [`list` and `str.join()`][approach-list-and-join] approach.
@@ -104,8 +104,8 @@ def reverse(text):
     return "".join(output)
 ```
 
-This approach turns the string into a list of codepoints and then uses the `list.reverse()` method to re-arrange the list _in place_.
-After the reversal of the list, `str.join()` is used to create the reversed string.
+This approach turns the string into a `list` of codepoints and then uses the `list.reverse()` method to re-arrange the `list` _in place_.
+After the reversal of the `list`, `str.join()` is used to create the reversed string.
 
 For more details, see the [built-in `list.reverse()`][approach-built-in-list-reverse] approach.
 

exercises/practice/reverse-string/.approaches/list-and-join/content.md

@@ -1,4 +1,4 @@
-# Create a List and Use `str.join()` to Make A New String
+# Create a `list` and Use `str.join()` to Make A New String
 
 To avoid performance issues with concatenating to a string, this group of approaches uses one or more `list`s to perform swaps or reversals before joining the codepoints back into a string.
 This avoids the `O(n**2)` danger of repeated shifting/reallocation when concatenating long strings.
@@ -14,9 +14,9 @@ def reverse(text):
     return "".join(output)
 ```
 
-The code above iterates over the codepoints in the input text and uses `list.insert()` to insert each one into the output list.
+The code above iterates over the codepoints in the input text and uses `list.insert()` to insert each one into the `output` list.
 Note that `list.insert(0, codepoint)` _prepends_, which is very inefficient for `lists`, while appending takes place in (amortized) `O(1)` time.
-So this code incurs a time penalty because it forces repeated shifts of every element in the list with every insertion.
+So this code incurs a time penalty because it forces repeated shifts of every element in the `list` with every insertion.
 A small re-write using `range()` to change the iteration direction will boost performance:
 
 
@@ -33,12 +33,12 @@ def reverse(text):
     return "".join(output)
 ```
 
-This code iterates backward over the string using `range()`, and can therefore use `list.append()` to append to the output list in (amortized) constant time.
-However, the use of `str.join()` to unpack the list and create a string still makes this `O(n)`.
+This code iterates backward over the string using `range()`, and can therefore use `list.append()` to append to the `output` list in (amortized) constant time.
+However, the use of `str.join()` to unpack the `list` and create a string still makes this `O(n)`.
 This also takes `O(n)` space for the output `list`.
 
 
-## Variation #2: Convert Text to List and Use `range()` to Iterate Over Half the String, Swapping Values
+## Variation #2: Convert Text to a `list` and Use `range()` to Iterate Over Half the String, Swapping Values
 
 ```python
 def reverse(text):
@@ -54,7 +54,7 @@ def reverse(text):
 
 This variation calculates the midpoint which is then used with `range()` in a `for loop` to iterate over _half_ the indexes in the `output` list, swapping values into their reversed places.
 `str.join()` is then used to create a new string.
-This technique is quite speedy, and re-arranges the list of codepoints _in place_, avoiding expensive string concatenation.
+This technique is quite speedy, and re-arranges the `list` of codepoints _in place_, avoiding expensive string concatenation.
 It is still `O(n)` time complexity because `list()` and `str.join()` both iterate over the entire length of the input string.
 
 
@@ -101,7 +101,7 @@ Because of this issue, no timings are available for this variation.
 For code that keeps bytes together correctly, see the `bytearray` variation in the [additional approaches][approach-additional-approaches] approach.
 
 
-## Variation #5:  Use Generator Expression with Join to Iterate Backwards Over Codepoints List
+## Variation #5: Use Generator Expression with `str.join()` to Iterate Backwards Over Codepoints `list`
 
 ```python
 def reverse(text):
@@ -111,7 +111,7 @@ def reverse(text):
 ```
 
 This variation puts the for/while loop used in other strategies directly into `str.join()` using a generator expression.
-The text is first converted to a list and the generator-expression "swaps" the codepoints over the whole `list`, using `range()` for the indexes.
+The text is first converted to a `list` and the generator-expression "swaps" the codepoints over the whole `list`, using `range()` for the indexes.
 Interestingly, because of the work to create and manage the generator, this variation is actually _slower_ than using an auxiliary `list` and `loop` to manage codepoints and then calling `str.join()` separately.