Fixed spacing

Author: meatball133

exercises/practice/scrabble-score/.approaches/dictionary/content.md

@@ -16,10 +16,10 @@ This code starts with defining a constant LETTER_SCORES as a dictionary ([concep
 Then the `score` function is defined, which takes a `<word>` as an argument.
 
 The function returns the total score for the word using the built-in function [`sum`][sum].
- Sum is passed a [generator expression][generator-expression] that iterates over the letters in the word, looking up each score in LETTER_SCORES.
+Sum is passed a [generator expression][generator-expression] that iterates over the letters in the word, looking up each score in LETTER_SCORES.
 The generator expression produces the score values on the fly.
 This means that it doesn't use memory to store all the values from LETTER_SCORES.
-Instead, each value is looked up as needed by `sum`. 
+Instead, each value is looked up as needed by `sum`.
 
 Within the generator expression, the word is converted from lower to uppercase.
 Each letter of the word is looked up in LETTER_SCORES, and the score value is yielded to `sum` as `sum` iterates over the expression.
@@ -42,11 +42,10 @@ LETTER_SCORES = {
 
 def score(word):
     return sum(next(score for score, letters in LETTER_SCORES.items() if character in letters) for character in word.upper())
-
+```
 
 However, transposing the dictionary so that the keys are the score and the values are the letters requires more computational calculation (_a loop within a loop_) and is harder to read.
- Therefore, arranging the dictionary by letter is both more efficient and easier to understand.
-
+Therefore, arranging the dictionary by letter is both more efficient and easier to understand.
 
 [dictionary]: https://docs.python.org/3/library/stdtypes.html#mapping-types-dict
 [generator-expression]: https://peps.python.org/pep-0289/

exercises/practice/scrabble-score/.approaches/enum/content.md

@@ -14,6 +14,7 @@ class Scrabble(IntEnum):
 
 def score(word):
     return sum(Scrabble[character] for character in word.upper())
+```
 
 This approach uses an [`Enum`][enum] to define the score of each letter.
 An [`Enum`][enum] (_also known as an **enumeration**_) is an object with named attributes assigned unique values.
@@ -24,7 +25,7 @@ Values can be accessed via index syntax using the member name (_similar to how a
 The `enum` module was added to python standard library (_also known as stdlib_) in Python 3.4.
 
 This approach uses an [`IntEnum`][int-enum].
-An `IntEnum` is very similar to  an `Enum`, but restricts assigned values to `int`s.
+An `IntEnum` is very similar to an `Enum`, but restricts assigned values to `int`s.
 This allows the `IntEnum` to act as a collection of integers.
 In fact, `IntEnum`s are considered subclasses of `int`s.
 
@@ -35,15 +36,16 @@ The `IntEnum` subclass is defined by using the [`class`][classes] keyword, follo
 
 ```python
 class ClassName(IntEnum):
+```
 
 Member names are declared as constants (ALL CAPS) and assigned values using the `=` operator.
 
-This approach works by creating all the uppercase letters as members with their values being the score. 
+This approach works by creating all the uppercase letters as members with their values being the score.
 After the `IntEnum` is defined, the `score` function is defined.
 
 The `score` function takes a word as an argument.
 The `score` function uses the same [generator expression][generator-expression] as the [dictionary approach][dictionary-approach], but with a slight modification.
-Instead of looking up the value in a _dictionary_,  it looks up the `InEnum` class member value.
+Instead of looking up the value in a _dictionary_, it looks up the `InEnum` class member value.
 
 [classes]: https://docs.python.org/3/tutorial/classes.html
 [enum]: https://docs.python.org/3/library/enum.html

exercises/practice/scrabble-score/.approaches/introduction.md

@@ -25,6 +25,7 @@ LETTER_SCORES = {
 
 def score(word):
     return sum(LETTER_SCORES[letter] for letter in word.upper())
+```
 
 For more information, check the [Dictionary Approach][dictionary-approach].
 
@@ -38,15 +39,15 @@ KEYS = "AEIOULNRSTDGBCMPFHVWYKJXQZ"
 SCORES = [1] * 10 + [2] * 2 + [3] * 4 + [4] * 5 + [5] * 1 + [8] * 2 +[10] * 2
 
 def score(word):
-    return sum(SCORES[KEYS.index(letter] for letter in word.upper())
+    return sum(SCORES[KEYS.index(letter)] for letter in word.upper())
 ```
 
 For more information, check the [Two Sequences Approach][two-sequences-approach].
 
 ## Approach: Enum
 
 Using an `Enum` is is short and easy to read.
-Although  creating an `Enum` can be more complicated since it uses OOP (object oriented programming).
+Although creating an `Enum` can be more complicated since it uses OOP (object oriented programming).
 
 ```python
 from enum import IntEnum
@@ -84,8 +85,9 @@ LETTERS_OF_SCORE = (
 )
 
 def score(word):
-        return sum(score for character in word.upper() for 
-        letters, score in LETTERS_OF_SCORE if character in letters)
+    return sum(score for character in word.upper() for
+    letters, score in LETTERS_OF_SCORE if character in letters)
+```
 
 For more information, check the [Nested Tuple Approach][nested-tuple-approach].
 

exercises/practice/scrabble-score/.approaches/nested-tuple/content.md

@@ -12,10 +12,11 @@ LETTERS_OF_SCORE = (
 )
 
 def score(word):
-    return sum(score for character in word.upper() for 
+    return sum(score for character in word.upper() for
     letters, score in LETTERS_OF_SCORE if character in letters)
+```
 
-The code starts with defining a constant, LETTERS_OF_SCORE as a [`tuple`][tuple] of tuples (_also known as a nested tuple_).
+The code starts with defining a constant, `LETTERS_OF_SCORE` as a [`tuple`][tuple] of tuples (_also known as a nested tuple_).
 Inside of the inner tuples are 2 values, the first value is a string of letters and the second value is the score for those letters.
 
 Next, the `score` function is defined, taking a word as an argument.
@@ -29,6 +30,6 @@ You can read more about unpacking in the [concept:python/unpacking-and-multiple-
 
 Then the code checks if the character is in the unpacked letters and if it is we return its score.
 
-[tuple]: https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences
 [generator-expression]: https://peps.python.org/pep-0289/
 [for-loop]: https://realpython.com/python-for-loop/
+[tuple]: https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences

exercises/practice/scrabble-score/.approaches/two-sequences/content.md

@@ -6,6 +6,7 @@ SCORES = [1] * 10 + [2] * 2 + [3] * 4 + [4] * 5 + [5] * 1 + [8] * 2 + [10] * 2
 
 def score(word):
     return sum(SCORES[KEYS.index(letter)] for letter in word.upper())
+```
 
 This approach uses a string and a [list][list], both of which are [sequence][sequence] types.
 The code begins by defining a string constant with letters.