Started

Author: meatball133

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

@@ -0,0 +1,51 @@
+# Dictionary
+
+```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
+}
+
+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 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.
+
+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/
+[sum]: https://docs.python.org/3/library/functions.html#sum

exercises/practice/scrabble-score/.approaches/Dictionary/snippet.txt

@@ -0,0 +1,2 @@
+def score(word):
+    return sum(LETTER_SCORES[letter.upper()] for letter in word)

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

@@ -0,0 +1,44 @@
+# Enum
+
+```python
+from enum import IntEnum
+
+class Scrabble(IntEnum):
+    A = E = I = O = U = L = N = R = S = T = 1
+    D = G = 2
+    B = C = M = P = 3
+    F = H = V = W = Y = 4
+    K = 5
+    J = X = 8
+    Q = Z = 10
+
+def score(word):
+    return sum(Scrabble[char.upper()] for char 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.
+
+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.
+
+To use an `intEnum` you need to [import][import] it using: `from enum import IntEnum`.
+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.
+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.
+
+[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/
+[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/Enum/snippet.txt

@@ -0,0 +1,8 @@
+class Scrabble(IntEnum):
+    A = E = I = O = U = L = N = R = S = T = 1
+    D = G = 2
+    B = C = M = P = 3
+    F = H = V = W = Y = 4
+    K = 5
+    J = X = 8
+    Q = Z = 10

exercises/practice/scrabble-score/.approaches/config.json

@@ -0,0 +1,36 @@
+{
+  "introduction": {
+    "authors": ["meatball133", "bethanyg"],
+    "contributors": []
+  },
+  "approaches": [
+    {
+      "uuid": "62f556c0-27a6-43e5-80ea-d7abd921f0e7",
+      "slug": "enum",
+      "title": "Enum",
+      "blurb": "Define a enum to solve the problem",
+      "authors": ["meatball133", "bethanyg"]
+    },
+    {
+      "uuid": "21c0fe14-585f-4e14-9f31-1d294a8a622c",
+      "slug": "dictionary",
+      "title": "Dictionary",
+      "blurb": "Dictionary approach",
+      "authors": ["meatball133", "bethanyg"]
+    },
+    {
+      "uuid": "34911050-b424-4289-9d3f-aa5f0e8f1630",
+      "slug": "nested-tuple",
+      "title": "Nested Tuple",
+      "blurb": "Nested Tuple approach",
+      "authors": ["meatball133", "bethanyg"]
+    },
+    {
+      "uuid": "e9b8e10b-23c7-4c2a-afbe-3c3499468919",
+      "slug": "two-sequences",
+      "title": "Two Sequences",
+      "blurb": "Two Sequences approach",
+      "authors": ["meatball133", "bethanyg"]
+    }
+  ]
+}

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

@@ -0,0 +1,115 @@
+# Introduction
+
+There are various ways to solve `scrabble-score`.
+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
+
+## Approach: Using a single dictionary
+
+Using a single dictionary is an approach, it is simple and fast.
+It is also very pythonic.
+
+```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
+}
+
+def score(word):
+    return sum(LETTER_SCORES[letter.upper()] for letter in word)
+```
+
+For more information, check the [Dictionary Approach][dictionary-approach].
+
+## Approach: Using two sequences
+
+Using two sequences is an approach, it is fast.
+Although the reason you might not want to do this is that it is hard to read.
+
+```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)
+```
+
+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.
+
+```python
+from enum import IntEnum
+
+class Scrabble(IntEnum):
+    A = E = I = O = U = L = N = R = S = T = 1
+    D = G = 2
+    B = C = M = P = 3
+    F = H = V = W = Y = 4
+    K = 5
+    J = X = 8
+    Q = Z = 10
+
+def score(word):
+    return sum(Scrabble[char.upper()] for char in word)
+```
+
+You can read more about how to achieve this optimization in: [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.
+
+```python
+LETTERS_OF_SCORE = (
+    ("AEIOULNRST", 1),
+    ("DG", 2),
+    ("BCMP", 3),
+    ("FHVWY", 4),
+    ("K", 5),
+    ("JX", 8),
+    ("QZ", 10),
+)
+
+def score(word):
+    return sum(for character in word for letters, score in LETTERS_OF_SCORE if character in letters)
+```
+
+For more information, check the [Nested Tuple Approach][nested-tuple-approach].
+
+[dictionary-approach]: https://exercism.org/tracks/python/exercises/scrabble-score/approaches/dictionary
+[enum-approach]: https://exercism.org/tracks/python/exercises/scrabble-score/approaches/enum
+[nested-tuple-approach]: https://exercism.org/tracks/python/exercises/scrabble-score/approaches/nested-tuple
+[two-sequences-approach]: https://exercism.org/tracks/python/exercises/scrabble-score/approaches/two-sequences

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

@@ -0,0 +1,32 @@
+# Nested Tuple
+
+```python
+LETTERS_OF_SCORE = (
+    ("AEIOULNRST", 1),
+    ("DG", 2),
+    ("BCMP", 3),
+    ("FHVWY", 4),
+    ("K", 5),
+    ("JX", 8),
+    ("QZ", 10),
+)
+
+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.
+
+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.
+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]().
+
+Then we check if the character is in the letters and if it is we return the score.
+
+[tuple]: https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences
+[generator-expersion]: https://peps.python.org/pep-0289/
+[for-loop]: https://realpython.com/python-for-loop/

exercises/practice/scrabble-score/.approaches/nested-tuple/snippet.txt

@@ -0,0 +1,8 @@
+LETTERS_OF_SCORE = (
+    ("AEIOULNRST", 1),
+    ("DG", 2),
+    ("BCMP", 3),
+    ("FHVWY", 4),
+    ("K", 5),
+    ("JX", 8),
+    ("QZ", 10),)

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

@@ -0,0 +1,25 @@
+# Two sequences
+
+```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)
+```
+
+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.
+
+The `score` function takes a word as a parameter.
+And uses the same [generator expression][generator-expersion] as the [dictionary approach][dictionary-approach].
+
+The difference is that instead of using a [dictionary][dictionary] and looked up the score inside.
+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.
+
+[dictionary]: https://docs.python.org/3/library/stdtypes.html#mapping-types-dict
+[dictionary-approach]: https://exercism.org/tracks/python/exercises/scrabble-score/approaches/dictionary
+[list]: https://docs.python.org/3/tutorial/datastructures.html#more-on-lists
+[sequence]: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
+[generator-expersion]: https://peps.python.org/pep-0289/

exercises/practice/scrabble-score/.approaches/two-sequences/snippet.txt

@@ -0,0 +1,5 @@
+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)