Added preformance article and a bunch of content to approaches

Author: meatball133

exercises/practice/rotational-cipher/.approaches/alphabet/content.md

@@ -0,0 +1,46 @@
+# Alphabet
+
+```python
+AlPHABET = "abcdefghijklmnopqrstuvwxyz"
+
+def rotate(text, key):
+    result = ""
+    for letter in text:
+        if letter.isalpha():
+            if letter.isupper():
+                result += AlPHABET[(AlPHABET.index(letter.lower()) + key) % 26].upper()
+            else:
+                result += AlPHABET[(AlPHABET.index(letter) + key) % 26]
+        else:
+            result += letter
+    return result
+```
+
+The approach starts with defining the a constant which holds the whole alphabets lowercase letters.
+After that the function `rotate` is declared, then a variable `result` is defined with the value of an empty string.
+
+Then is all the letters from the text argument iterated over through a [`for loop`][for-loop].
+Then is checked if the letter is a letter, if it is a letter then is checked if it is a uppercased letter.
+
+If it is a uppercased letter then it is converted to lowe case and finds its index in the `AlPHABET` constant.
+Then is the key added to the index and [modulo (`%`)][modulo] 26 is used on the result.
+Then is the letter at the index found in the `AlPHABET` constant and the letter is converted to upcase.
+
+If the letter is a lowercased letter then it does the same process but don't convert the letter to downcase and then to uppercase.
+
+If the letter is not a letter then is the letter added to the result.
+When the loop is finished we return the result.
+
+If you only want to use english letters so could you import the alphabet instead of defining it yourself.
+Since in the [`string`][string] module there is a constant called [`ascii_lowercase`][ascii_lowercase] which holds the lowercased alphabet.
+
+```python
+import string
+
+AlPHABET = string.ascii_lowercase
+```
+
+[ascii_lowercase]: https://docs.python.org/3/library/string.html#string.ascii_letters
+[for-loop]: https://realpython.com/python-for-loop/
+[modulo]: https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations
+[string]: https://docs.python.org/3/library/string.html

exercises/practice/rotational-cipher/.approaches/alphabet/snippet.txt

@@ -0,0 +1,8 @@
+for letter in text:
+    if letter.isalpha():
+        if letter.isupper():
+            result += AlPHABET[(AlPHABET.index(letter.lower()) + key) % 26].upper()
+        else:
+            result += AlPHABET[(AlPHABET.index(letter) + key) % 26]
+    else:
+        result += letter

exercises/practice/rotational-cipher/.approaches/ascii-values/content.md

@@ -1,7 +1,7 @@
 # Ascii
 
 ```python
-def rotate(text, key)
+def rotate(text, key):
     result = ""
     for letter in text:
         if letter.isalpha():
@@ -25,16 +25,20 @@ While the upcased letters are in the range between 65 and 91.
 The reason why you might not want to do this approach is that it only supports the english alphabet.
 
 The approach starts with defining the function `rotate`, then a variable `result` is defined with the value of an empty string.
-Then is all the letters from the text iterated over through a `for loop`.
+Then is all the letters from the text argument iterated over through a [`for loop`][for-loop].
 Then is checked if the letter is a letter, if it is a letter then is checked if it is a uppercased letter.
-If it is a uppercased letter then is `ord` used which converts a letter to an ascii and is then added with the key and the ascii value of the letter subtracted with 65.
-Then is the result of that modulo 26 added with 65.
+
+Python has a built in function called `ord` that converts a [unicode][unicode] symbol to an integer.
+The unicode's first 128 characters are the same as ascii.
+
+If it is a uppercased letter then is [`ord`][ord] used to convert the letters to an integer and is then added with the key and then subtracted with 65.
+Then is the result of that [modulo (`%`)][modulo] 26 added with 65.
 
 That is because we want to know which index in the alphabet the letter is.
 And if the number is over 26 we want to make sure that it is in the range of 0-26.
 So we use modulo to make sure it is in that range.
-To use modulo for a range we have to make sure that it starts at zero, thereby are we subtracting the ascii value of the letter with 65.
-After that to get the back to a letter we add 65 and use the `chr` method which converts an ascii value to a letter.
+To use modulo for a range we have to make sure that it starts at zero, thereby are we subtracting the integer value of the letter with 65.
+After that to get the back to a letter we add 65 and use the [`chr`][chr] method which converts an an unicode value to a letter.
 After that is the new letter added to the result.
 
 If the letter is a lowercased letter then is the same done but with the ascii value of 97 subtracted with the letter.
@@ -43,3 +47,8 @@ If the letter is not a letter then is the letter added to the result.
 When the loop is finished we return the result.
 
 [ascii]: https://en.wikipedia.org/wiki/ASCII
+[chr]: https://docs.python.org/3/library/functions.html#chr
+[for-loop]: https://realpython.com/python-for-loop/
+[modulo]: https://realpython.com/python-modulo-operator/
+[ord]: https://docs.python.org/3/library/functions.html#ord
+[unicode]: https://en.wikipedia.org/wiki/Unicode

exercises/practice/rotational-cipher/.approaches/ascii-values/snippet.txt

@@ -1,5 +1,8 @@
-    for number_a in range(min_factor, max_factor+1):
-        for number_b in range(min_factor, max_factor+1):
-            if number_a * number_b >= result:
-                test_value = str(number_a * number_b)
-                if test_value == test_value[::-1]:
+for letter in text:
+    if letter.isalpha():
+        if letter.isupper():
+            result += chr((ord(letter) - 65 + key) % 26 + 65)
+        else:
+            result += chr((ord(letter) - 97 + key) % 26 + 97)
+    else:
+        result += letter

exercises/practice/rotational-cipher/.approaches/config.json

@@ -13,9 +13,23 @@
     },
     {
       "uuid": "6eb99523-b12b-4e72-8ed8-3444b635b9e5",
-      "slug": "nested-for-loop-optimized",
-      "title": "Nested for loop optimized",
-      "blurb": "Nested for loop optimized edition",
+      "slug": "alphabet",
+      "title": "Alphabet",
+      "blurb": "Using the alphabet to rotate the alphabet",
+      "authors": ["meatball133", "bethanyg"]
+    },
+    {
+      "uuid": "e539d1a5-f497-402b-a232-7e889f4323c1",
+      "slug": "str-translate",
+      "title": "Str Translate",
+      "blurb": "Using str.translate to rotate the alphabet",
+      "authors": ["meatball133", "bethanyg"]
+    },
+    {
+      "uuid": "0c74890e-d96e-47a2-a8bf-93c45dd67f94",
+      "slug": "recursion",
+      "title": "Recursion",
+      "blurb": "Using Recursion to rotate the alphabet",
       "authors": ["meatball133", "bethanyg"]
     }
   ]

exercises/practice/rotational-cipher/.approaches/introduction.md

@@ -1,12 +1,11 @@
 # Introduction
 
-There are various ways to solve `palindrome-products`.
-This approaches document shows 2 _common_ strategies, with one being a lot more efficient than the other.
-That being said, neither approach here is considered canonical, and other "pythonic" approaches could be added/expanded on in the future.
+There are various ways to solve `rotational-cipher`.
+You can for example use a [ascii values][ascii], alphabet, recursion, and `str.translate`.
 
 ## General guidance
 
-The goal of this exercise is to generate the largest and smallest palindromes from a given range of numbers.
+The goal of this exercise is to rotate the letters in a string by a given key.
 
 ## Approach: Using ascii values
 
@@ -16,11 +15,11 @@ There the numbers 65-91 in the ascii range represent downcased letters.
 While 97-123 represent upcased letters.
 
 The reason why you might not want to do this approach is that it only supports the english alphabet.
-Say we want to use the scandivanian letter: **ä**, then this approach will not work.
-Since **ä** has the ascii value of 132.
+Say we want to use the scandinavian letter: **å**, then this approach will not work.
+Since **å** has the ascii value of 132.
 
 ```python
-def rotate(text, key)
+def rotate(text, key):
     result = ""
     for letter in text:
         if letter.isalpha():
@@ -33,14 +32,16 @@ def rotate(text, key)
     return result
 ```
 
+For more information, check the [ascii values approach][approach-ascii-values].
+
 ## Approach: Alphabet
 
 This approach is similar to the previous one, but instead of using the ascii values, it uses the index of the letter in the alphabet.
 It requires the storing of a string and unless you are using two strings you have to convert the letters from upper to lower case.
 
-What this approach although give is the posiblity to use any alphabet.
-Say we want to use the scandivanian letter: **ä**, then we just add it where we want it:
-`abcdefghijklmnopqrstuvwxyzä` and it will rotate correctley around that.
+What this approach although give is the possibility to use any alphabet.
+Say we want to use the scandinavian letter: **å**, then we just add it where we want it:
+`abcdefghijklmnopqrstuvwxyzå` and it will rotate correctly around that.
 
 ```python
 AlPHABET = "abcdefghijklmnopqrstuvwxyz"
@@ -58,13 +59,13 @@ def rotate(text, key):
     return result
 ```
 
-For more information, check the [Nested for loop approach][approach-nested-for-loop].
+For more information, check the [Alphabet approach][approach-alphabet].
 
 ## Approach: Str translate
 
 This approach is similar to the previous one, but instead of using the index of the letter in the alphabet, it uses the `str.translate` method.
-The benefit of this approach is that it has no visable loop, thereby the code becomes more concise.
-What to note is that the `str.translate` still loops over the `string` thereby even if it is no visable loop, it doesn't mean that a method is not looping.
+The benefit of this approach is that it has no visible loop, thereby the code becomes more concise.
+What to note is that the `str.translate` still loops over the `string` thereby even if it is no visible loop, it doesn't mean that a method is not looping.
 
 ```python
 AlPHABET = "abcdefghijklmnopqrstuvwxyz"
@@ -74,7 +75,7 @@ def rotate(text, key):
     return text.translate(str.maketrans(AlPHABET + AlPHABET.upper(), translator + translator.upper()))
 ```
 
-You can read more about how to achieve this optimization in: [Nested for loop optimized][approach-nested-for-loop-optimized].
+For more information, check the [Str translate approach][approach-str-translate].
 
 ## Approach: Recursion
 
@@ -100,10 +101,16 @@ def rotate(text, key):
         return first_letter + rotate(rest, key)
 ```
 
+For more information, check the [Recursion approach][approach-recursion].
+
 ## Benchmark
 
 For more information, check the [Performance article][article-performance].
 
-[approach-nested-for-loop]: https://exercism.org/tracks/python/exercises/palindrome-products/approaches/nested-for-loop
-[approach-nested-for-loop-optimized]: https://exercism.org/tracks/python/exercises/palindrome-products/approaches/nested-for-loop-optimized
-[article-performance]: https://exercism.org/tracks/python/exercises/palindrome-products/articles/performance
+[ascii]: https://en.wikipedia.org/wiki/ASCII
+[approach-recursion]: https://exercism.org/tracks/python/exercises/rotational-cipher/approaches/recursion
+[approach-str-translate]: https://exercism.org/tracks/python/exercises/rotational-cipher/approaches/str-translate
+[approach-ascii-values]: https://exercism.org/tracks/python/exercises/rotational-cipher/approaches/ascii-values
+[approach-alphabet]: https://exercism.org/tracks/python/exercises/rotational-cipher/approaches/alphabet
+[article-performance]: https://exercism.org/tracks/python/exercises/rotational-cipher/articles/performance
+[recursion-limit]: https://docs.python.org/3/library/sys.html#sys.setrecursionlimit

exercises/practice/rotational-cipher/.approaches/nested-for-loop-optimized/content.md

@@ -0,0 +1,42 @@
+# Recursion
+
+```python
+AlPHABET = "abcdefghijklmnopqrstuvwxyz"
+
+def rotate(text, key):
+    if text == "":
+        return ""
+    first_letter, rest = text[0], text[1:]
+    if first_letter.isalpha():
+        if first_letter.isupper():
+            return AlPHABET[(AlPHABET.index(first_letter.lower()) + key) % 26].upper() + rotate(rest, key)
+        else:
+            return AlPHABET[(AlPHABET.index(first_letter) + key) % 26] + rotate(rest, key)
+    else:
+        return first_letter + rotate(rest, key)
+```
+
+This approach uses a very similar approach to alphabet.
+And uses the same logic but instead of a loop so does this approach use [concept:python/recursion]() to solve the problem.
+
+Recursion is a programming technique where a function calls itself.
+It is a powerful technique, but can be more tricky to implement than a while loop.
+Recursion isn't that common in Python, it is more common in functional programming languages, like: [Elixir][elixir], [Haskell][haskell], and [Clojure][clojure].
+
+Solving this exercise with recursion removes the need for a "result" variable and the instantiation of a `loop`.
+If the number is not equal to one, we call `<letter> + rotate(rest)`.
+Then the `rotate` function can execute the same code again with new values.
+Meaning we can get a long chain or stack of `<letter> + rotate(rest)` until the rest variable is exhausted and then the code adds `""`.
+That translates to something like this: `<letter> + <letter> + <letter> + <letter> + ""`.
+
+In Python, we can't have a function call itself more than 1000 times by default.
+Code that exceeds this recursion limit will throw a [RecursionError][recursion-error].
+While it is possible to adjust the [recursion limit][recursion-limit], doing so risks crashing Python and may also crash your system.
+Casually raising the recursion limit is not recommended.
+
+[clojure]: https://exercism.org/tracks/clojure
+[elixir]: https://exercism.org/tracks/elixir
+[haskell]: https://exercism.org/tracks/haskell
+[recursion]: https://realpython.com/python-thinking-recursively/
+[recursion-error]: https://docs.python.org/3/library/exceptions.html#RecursionError
+[recursion-limit]: https://docs.python.org/3/library/sys.html#sys.setrecursionlimit

exercises/practice/rotational-cipher/.approaches/nested-for-loop-optimized/snippet.txt

@@ -0,0 +1,8 @@
+first_letter, rest = text[0], text[1:]
+if first_letter.isalpha():
+    if first_letter.isupper():
+        return AlPHABET[(AlPHABET.index(first_letter.lower()) + key) % 26].upper() + rotate(rest, key)
+    else:
+        return AlPHABET[(AlPHABET.index(first_letter) + key) % 26] + rotate(rest, key)
+else:
+    return first_letter + rotate(rest, key)