Apply suggestions from code review

Co-authored-by: BethanyG <[email protected]>

Author: meatball133

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

@@ -2,50 +2,52 @@
 
 ```python
 LETTER_SCORES = {
-    'A': 1,
-    'E': 1,
-    'I': 1,
-    'O': 1,
-    'U': 1,
-    'L': 1,
-    'N': 1,
-    'R': 1,
-    'S': 1,
-    'T': 1,
-    'D': 2,
-    'G': 2,
-    'B': 3,
-    'C': 3,
-    'M': 3,
-    'P': 3,
-    'F': 4,
-    'H': 4,
-    'V': 4,
-    'W': 4,
-    'Y': 4,
-    'K': 5,
-    'J': 8,
-    'X': 8,
-    'Q': 10,
-    'Z': 10
+    'A': 1, 'E': 1, 'I': 1, 'O': 1, 'U': 1,
+    'L': 1, 'N': 1, 'R': 1, 'S': 1, 'T': 1,
+    'D': 2, 'G': 2, 'B': 3, 'C': 3, 'M': 3,
+    'P': 3, 'F': 4, 'H': 4, 'V': 4, 'W': 4,
+    'Y': 4, 'K': 5, 'J': 8, 'X': 8, 'Q': 10, 'Z': 10
 }
-
 def score(word):
-    return sum(LETTER_SCORES[letter.upper()] for letter in word)
+    return sum(LETTER_SCORES[letter] for letter in word.upper())
 ```
 
-The code starts with initializing a constant that is a [dictionary][dictionary] there each letter is a key and their respective score as a value.
-Then a function is defined that takes a word as an argument.
+This code starts with defining a constant LETTER_SCORES as a dictionary ([concept:python/dicts](https://docs.python.org/3/library/stdtypes.html#mapping-types-dict)) where each letter is a key and the corresponding score is a value.
+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.
+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`. 
+
+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.
+This is almost exactly the same process as using a `list comprehension`.
+However, a `list comprehension` would look up the values and save them into a `list` in memory.
+`sum` would then "unpack" or iterate over the `list`.
+
+A variation on this dictionary approach is to use a dictionary transposition.
+
+```python
+LETTER_SCORES = {
+    1: {'A', 'E', 'I', 'O', 'U', 'L', 'N', 'R', 'S', 'T'},
+    2: {'D', 'G'},
+    3: {'B', 'C', 'M', 'P'},
+    4: {'F', 'H', 'V', 'W', 'Y'},
+    5: {'K'},
+    8: {'J', 'X'},
+    10: {'Q', 'Z'}
+}
+
+def score(word):
+    return sum(next(score for score, letters in LETTER_SCORES.items() if character in letters) for character in word.upper())
 
-The function returns the built in function [`sum`][sum] that takes a [generator expression][generator-expersion] that iterates over the letters in the word.
-What a generator expression does is that it generates the values on the fly.
-Meaning that it doesn't have to use a lot of memory since it uses the last value and generates the next value.
 
-Under the generation a letter is given from the string, then it is converted to upcase, and then being looked up at inside of the dictionary and the value is returned.
+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.
 
-There is also a very similar approach that uses a dictionary transposition.
-Although that approach requires more computational calculation therefore is this approach more efficient.
 
 [dictionary]: https://docs.python.org/3/library/stdtypes.html#mapping-types-dict
-[generator-expersion]: https://peps.python.org/pep-0289/
+[generator-expression]: https://peps.python.org/pep-0289/
 [sum]: https://docs.python.org/3/library/functions.html#sum

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

@@ -13,32 +13,40 @@ class Scrabble(IntEnum):
     Q = Z = 10
 
 def score(word):
-    return sum(Scrabble[character.upper()] for character in 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` or known as an **enumeration** is sets of named constant and is immutable.
-`enum` was added to python standard library (_also known as stdlib_) in python 3.4.
+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.
+These attributes are referred to as the enumeration _members_.
+`Enum`s can be iterated over to return their members in definition order.
+Values can be accessed via index syntax using the member name (_similar to how a dictionary lookup works_) .
+`Enum`s are immutable, and their members function as constants.
+The `enum` module was added to python standard library (_also known as stdlib_) in Python 3.4.
 
-This approach uses an [`intEnum`][int-enum] it works very similar to a normal `enum` but it has the added benefit that the values are integers.
-Thereby acts like integers.
+This approach uses an [`IntEnum`][int-enum].
+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.
 
-To use an `intEnum` you need to [import][import] it using: `from enum import IntEnum`.
-Then you can define the `enum` class.
+To use an `IntEnum` you need to first [import][import] it using: `from enum import IntEnum`.
+Then you can define your `IntEnum` subclass.
 
-The `enum` class is defined by using the [`class`][classes] keyword.
-Then you need to specify the name of the class.
+The `IntEnum` subclass is defined by using the [`class`][classes] keyword, followed by the name you are using for the class, and then the `IntEnum` class you are subclassing in parenthesis:
 
-After that is the constant in the enum declared by giving the constant capital letters and the value is assigned by using the `=` operator.
-This approach works by giving all the letters as constants and then value of the constant is the score of the letter.
-After the `enum` is defined, the `score` function is defined.
+```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. 
+After the `IntEnum` is defined, the `score` function is defined.
 
-The `score` function takes a word as a parameter.
-And uses the same [generator expression][generator-expersion] as the [dictionary approach][dictionary-approach] but with a slight modification.
-Which is that instead of looking up the value in a dictionary it looks it up in the `enum` class.
+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.
 
 [classes]: https://docs.python.org/3/tutorial/classes.html
 [enum]: https://docs.python.org/3/library/enum.html
-[generator-expersion]: https://peps.python.org/pep-0289/
+[generator-expression]: https://peps.python.org/pep-0289/
 [int-enum]: https://docs.python.org/3/library/enum.html#enum.IntEnum
 [import]: https://docs.python.org/3/reference/import.html

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

@@ -1,73 +1,52 @@
 # Introduction
 
 There are various ways to solve `scrabble-score`.
-This approache document shows different strategies to solve this exercise.
+This approaches document shows different strategies to solve this exercise.
 
 ## General guidance
 
 The goal of this exercise is to write a function that calculates the scrabble score for a given word.
-The problem is that the scrabble score is calculated by the sum of the scores of each letter in the word.
+The challenge is that the scrabble score is calculated by summing the scores of individual letters in a word.
+The student needs to find an efficient and easily accessed way to store individual letter scores for lookup when processing different words.
 
 ## Approach: Using a single dictionary
 
-Using a single dictionary is an approach, it is simple and fast.
-It is also very pythonic.
+Using a single dictionary for letter lookup is simple and fast.
+It is also very pythonic, and could be considered the canonical approach to this exercise.
 
 ```python
 LETTER_SCORES = {
-    'A': 1,
-    'E': 1,
-    'I': 1,
-    'O': 1,
-    'U': 1,
-    'L': 1,
-    'N': 1,
-    'R': 1,
-    'S': 1,
-    'T': 1,
-    'D': 2,
-    'G': 2,
-    'B': 3,
-    'C': 3,
-    'M': 3,
-    'P': 3,
-    'F': 4,
-    'H': 4,
-    'V': 4,
-    'W': 4,
-    'Y': 4,
-    'K': 5,
-    'J': 8,
-    'X': 8,
-    'Q': 10,
-    'Z': 10
+    'A': 1, 'E': 1, 'I': 1, 'O': 1, 'U': 1,
+    'L': 1, 'N': 1, 'R': 1, 'S': 1, 'T': 1,
+    'D': 2, 'G': 2, 'B': 3, 'C': 3, 'M': 3,
+    'P': 3, 'F': 4, 'H': 4, 'V': 4, 'W': 4,
+    'Y': 4, 'K': 5, 'J': 8, 'X': 8, 'Q': 10, 'Z': 10
 }
 
 def score(word):
-    return sum(LETTER_SCORES[letter.upper()] for letter in word)
-```
+    return sum(LETTER_SCORES[letter] for letter in word.upper())
 
 For more information, check the [Dictionary Approach][dictionary-approach].
 
 ## Approach: Using two sequences
 
-Using two sequences is an approach, it removes the need of using a nested data structure or a dictonary.
-Although the reason you might not want to do this is that it is hard to read.
+Using two sequences removes the need to use a nested data structure or a dictionary.
+Although you might not want to use this approach because it is hard to read and maintain.
 
 ```python
 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.upper())] for letter in word)
+    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 an approach, it is short and easy to read.
-Although it is more complicated since it uses a oop (object oriented programmering) elements.
+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).
 
 ```python
 from enum import IntEnum
@@ -82,15 +61,16 @@ class Scrabble(IntEnum):
     Q = Z = 10
 
 def score(word):
-    return sum(Scrabble[letter.upper()] for letter in word)
+    return sum(Scrabble[letter] for letter in word.upper())
 ```
 
 For more information, check the [Enum Approach][enum-approach].
 
 ## Approach: Using a nested tuple
 
-Tuples in python is more memory efficent than using a dictonary in python.
-Although this solution since it is iterating over a tuple for every letter so is it slower.
+Using a tuple in Python is generally more memory efficient than using a dictionary.
+However, this solution requires iterating over the entire `tuple` for every letter in order to score a full word.
+This makes the solution slower than the dictionary approach.
 
 ```python
 LETTERS_OF_SCORE = (
@@ -104,8 +84,8 @@ LETTERS_OF_SCORE = (
 )
 
 def score(word):
-    return sum(for character in word 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,23 +12,23 @@ LETTERS_OF_SCORE = (
 )
 
 def score(word):
-    return sum(score for character in word for letters, score in LETTERS_OF_SCORE if character.upper() in letters)
-```
+    return sum(score for character in word.upper() for 
+    letters, score in LETTERS_OF_SCORE if character in letters)
 
-The code starts with initializing a constant with a [tuple][tuple] of tuples (_also known as a nested tuple_).
-Inside of the inner tuples there is 2 values, the first value is a string of letters and the second value is the score for the letters.
+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.
 
-Then a function is defined that takes a word as an argument.
-The function returns a [generator expression][generator-expersion] similar to the [dictionary approach][dictionary-approach] but has some slight modifcations.
+Next, the `score` function is defined, taking a word as an argument.
+The `score` function uses a [generator expression][generator-expression] similar to the [dictionary approach][dictionary-approach] with some slight modifications.
 
-The difference is that this one uses a nested [for loop][for-loop] to iterate over the letters and the tuples.
-We first iterate over the characters in the word and then iterate over the tuples.
-Which means that for each letter are we iterating over all of the tuples.
-There the tuple is unpacked into the letters and the score.
+This particular approach uses a _nested_ [for loop][for-loop] to iterate over the letters and the tuples.
+We first iterate over the characters in the word and then the tuples.
+Which means that for **_each letter_** we iterate over **all** of the tuples.
+Each iteration, the tuple is unpacked into the letters and their corresponding score.
 You can read more about unpacking in the [concept:python/unpacking-and-multiple-assignment]().
 
-Then we check if the character is in the letters and if it is we return the score.
+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-expersion]: https://peps.python.org/pep-0289/
+[generator-expression]: https://peps.python.org/pep-0289/
 [for-loop]: https://realpython.com/python-for-loop/

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

@@ -5,19 +5,17 @@ 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.upper())] for letter in word)
-```
+    return sum(SCORES[KEYS.index(letter)] for letter in word.upper())
 
-This approach uses a string and a [list][list], both of these data types belongs to the parent data type [sequences][sequence].
-The code starts with defining a string constant with letters.
-Then another constant is definded which is a list with corresponding score for the same index as the string.
+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.
+Then another constant is defined as a list with the corresponding letter score at the same index as the letter in the string.
 
-The `score` function takes a word as a parameter.
-And uses the same [generator expression][generator-expersion] as the [dictionary approach][dictionary-approach] with some slight modifications.
+The `score` function takes a word as an argument.
+And uses the same [generator expression][generator-expression] as the [dictionary approach][dictionary-approach] with some slight modifications.
 
-The difference is that instead of using a [dictionary][dictionary] and looking up the score inside of a dictonary.
-This approach gets the index of the letter in the KEYS constant and then then looks up the value for that index in SCORES list.
-Then takes that value and return that to the generator expression.
+Instead of using a [dictionary][dictionary] and looking up the score, this approach looks up the index of the letter in the KEYS constant and then then looks up the value for that index in SCORES list within the generator expression.
+These values are then added up by `sum`.
 
 [dictionary]: https://docs.python.org/3/library/stdtypes.html#mapping-types-dict
 [dictionary-approach]: https://exercism.org/tracks/python/exercises/scrabble-score/approaches/dictionary