Fixes

Author: meatball133

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

@@ -34,8 +34,8 @@ def score(word):
     return sum(LETTER_SCORES[letter.upper()] for letter in word)
 ```
 
-The code starts with initializing a constant that is a [dictionary][dictionary] that holds all the letters as different key and their respective score as a value.
-Then it defines a function that takes a word as an argument.
+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.
 
 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.

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

@@ -13,12 +13,12 @@ class Scrabble(IntEnum):
     Q = Z = 10
 
 def score(word):
-    return sum(Scrabble[char.upper()] for char in word)
+    return sum(Scrabble[character.upper()] for character in word)
 ```
 
 This approach uses an [`enum`][enum] to define the score of each letter.
-An `enum` or known as a enumerations is sets of named constant and is immutable.
-`enum` was added to python standard library also known as stdlib in python 3.4.
+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 [`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.
@@ -29,13 +29,13 @@ Then you can define the `enum` class.
 The `enum` class is defined by using the [`class`][classes] keyword.
 Then you need to specify the name of the class.
 
-After that is constant declared by giving the constant capital letters and the value is assigned by using the `=` operator.
+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.
 
 The `score` function takes a word as a parameter.
-And uses the same [generator expression][generator-expersion] as the [dictionary approach][dictionary-approach].
-But instead of looking up the value in a dictionary it looks it up in the `enum` class.
+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.
 
 [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

@@ -1,12 +1,12 @@
 # Introduction
 
 There are various ways to solve `scrabble-score`.
-This approaches document shows different strategies to solve this exercise
+This approache 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 problem is that the scrabble score is calculated by the sum of the scores of each letter in the word.
 
 ## Approach: Using a single dictionary
 
@@ -51,7 +51,7 @@ For more information, check the [Dictionary Approach][dictionary-approach].
 
 ## Approach: Using two sequences
 
-Using two sequences is an approach, it is fast.
+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.
 
 ```python
@@ -67,7 +67,7 @@ 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 class.
+Although it is more complicated since it uses a oop (object oriented programmering) elements.
 
 ```python
 from enum import IntEnum
@@ -82,10 +82,10 @@ class Scrabble(IntEnum):
     Q = Z = 10
 
 def score(word):
-    return sum(Scrabble[char.upper()] for char in word)
+    return sum(Scrabble[letter.upper()] for letter in word)
 ```
 
-You can read more about how to achieve this optimization in: [Enum Approach][enum-approach].
+For more information, check the [Enum Approach][enum-approach].
 
 ## Approach: Using a nested tuple
 

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

@@ -15,13 +15,15 @@ def score(word):
     return sum(score for character in word for letters, score in LETTERS_OF_SCORE if character.upper() in letters)
 ```
 
-The code starts with initializing a constant with a [tuple][tuple] of tuples.
-Inside of the inner tuples there is 2 values, the first value is a string of letters and the second value is the score of the 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.
 
-Then it defines a function that takes a word as an argument.
-The function returns a [generator expression][generator-expersion] similar to the [dictionary approach][dictionary-approach].
-The difference is that it uses a nested [for loop][for-loop] to iterate over the letters and the tuples.
-There we iterate over the characters in the word and then iterate over the tuples.
+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.
+
+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.
 You can read more about unpacking in the [concept:python/unpacking-and-multiple-assignment]().
 

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

@@ -8,13 +8,14 @@ def score(word):
     return sum(SCORES[KEYS.index(letter.upper())] for letter in word)
 ```
 
-This approach uses a string and a [list][list], both of these data types belongs to the data type [sequences][sequence].
-It has a constant with a string with letters and then it has a constant of a list with corresponding score for the same index as the string.
+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.
 
 The `score` function takes a word as a parameter.
-And uses the same [generator expression][generator-expersion] as the [dictionary approach][dictionary-approach].
+And uses the same [generator expression][generator-expersion] as the [dictionary approach][dictionary-approach] with some slight modifications.
 
-The difference is that instead of using a [dictionary][dictionary] and looked up the score inside.
+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.