start

Author: meatball133

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

@@ -0,0 +1,45 @@
+# Ascii
+
+```python
+def rotate(text, key)
+    result = ""
+    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
+    return result
+```
+
+This approach uses [ascii values][ascii], ascii stands for American Standard Code for Information Interchange.
+It is a character encoding standard for electronic communication.
+It is a 7-bit code, which means that it can represent 128 different characters.
+The system uses numbers to represent various characters, symbols, and other entities.
+
+In ascii can you find all the downcased letter in the range between 97 and 123.
+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 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.
+
+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.
+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.
+
+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

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

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

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

@@ -0,0 +1,22 @@
+{
+  "introduction": {
+    "authors": ["meatball133", "bethanyg"],
+    "contributors": []
+  },
+  "approaches": [
+    {
+      "uuid": "ec09a4e1-6bc3-465b-a366-8ccdd2dbe093",
+      "slug": "ascii-values",
+      "title": "ASCII values",
+      "blurb": "Use letters ascii value to rotate the alphabet",
+      "authors": ["meatball133", "bethanyg"]
+    },
+    {
+      "uuid": "6eb99523-b12b-4e72-8ed8-3444b635b9e5",
+      "slug": "nested-for-loop-optimized",
+      "title": "Nested for loop optimized",
+      "blurb": "Nested for loop optimized edition",
+      "authors": ["meatball133", "bethanyg"]
+    }
+  ]
+}

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

@@ -0,0 +1,109 @@
+# 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.
+
+## General guidance
+
+The goal of this exercise is to generate the largest and smallest palindromes from a given range of numbers.
+
+## Approach: Using ascii values
+
+This approach is very simple and easy to understand.
+it uses the ascii value of the letters to rotate them.
+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.
+
+```python
+def rotate(text, key)
+    result = ""
+    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
+    return result
+```
+
+## 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.
+
+```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
+```
+
+For more information, check the [Nested for loop approach][approach-nested-for-loop].
+
+## 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.
+
+```python
+AlPHABET = "abcdefghijklmnopqrstuvwxyz"
+
+def rotate(text, key):
+    translator = AlPHABET[key:] + AlPHABET[: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].
+
+## Approach: Recursion
+
+In this approach we use a recursive function.
+A recursive function is a function that calls itself.
+This approach can be more concise than other approaches, and may also be more readable for some audiences.
+
+The reason why you might not want to use this approach is that Python has a [recursion limit][recursion-limit] with a default of 1000.
+
+```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)
+```
+
+## 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

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

@@ -0,0 +1,92 @@
+# Nested For Loop Optimized
+
+This approach shows that just a few changes can improve the running time of the solution significantly.
+
+```python
+def largest(min_factor, max_factor):
+    if min_factor > max_factor:
+        raise ValueError("min must be <= max")
+    result = 0
+    answer = []
+    for number_a in range(max_factor, min_factor - 1,-1):
+        was_bigger = False
+        for number_b in range(max_factor, number_a - 1, -1):
+            if number_a * number_b >= result:
+                was_bigger = True
+                test_value  = str(number_a * number_b)
+                if test_value == test_value[::-1]:
+                    if number_a * number_b > result:
+                        answer = []
+                        result = int(test_value)
+                    answer.append([number_a, number_b])
+        if not was_bigger:
+            break
+    if result == 0:
+        result = None
+    return (result, answer)
+
+
+def smallest(min_factor, max_factor):
+    if min_factor > max_factor:
+        raise ValueError("min must be <= max")
+    result = 0
+    answer = []
+    for number_a in range(min_factor, max_factor+1):
+        was_smaller = False
+        for number_b in range(min_factor, max_factor+1):
+            if number_a * number_b <= result or result == 0:
+                was_smaller = True
+                test_value = str(number_a * number_b)
+                if test_value == test_value[::-1]:
+                    if number_a * number_b < result:
+                        answer = []
+                    result = int(test_value)
+                    answer.append([number_a, number_b])
+        if not was_smaller:
+            break
+    if result == 0:
+        result = None
+    return (result, answer)
+```
+
+This approach is very similar to the [nested for loop approach][approach-nested-for-loop], but it has a few optimizations.
+To optimize the `largest` function, we have to start the inner loop from the maximum factor and proceed down to the minimum factor.
+This allows us to stop the inner loop earlier than before.
+We also set the minimum value in the _inner_ loop to the current value of the _outer_ loop.
+
+Here is an example of how the algorithm works and why the loops need to be modified.
+Say we take maximum to be 99 and the minimum 10.
+In the first round:
+
+```
+x = [99 , 98, 97 ...]
+y = [99]
+```
+
+And already we have our result: `9009[91,99]`
+Although the loops have to continue to make us sure there are no higher values.
+
+```
+x = [98, 97, 96 ...]
+y = [99, 98]
+...
+x = [90, 89, 88 ...]
+y = [99, 98,97,96,95,94,93,92,91,90]
+
+Here we can see that the highest value for this "run" is 90 \* 99 = 8910.
+Meaning that running beyond this point won't give us any values higher than 9009.
+
+That is why we introduce the `was_bigger` variable.
+With `was_bigger`, we can check if the inner loop has a bigger value than the current result.
+If there has not been a bigger value, we can stop the inner loop and stop the outer loop.
+We do that by using the [`break`][break] statement.
+
+If we hadn't modified the direction of the inner loop, it would have started from the minimum factor and gone up to the maximum factor.
+This would mean that for every new run in the outer loop, the values would be bigger than the previous run.
+
+The `smallest` function is optimized in a similar way as `largest` function compared to the original approach.
+The only difference is that we have to start the inner loop and outer loop from the minimum factor and go up to the maximum factor.
+Since what we want is the smallest value, we have to start from the smallest value and go up to the biggest value.
+
+[approach-nested-for-loop]: https://exercism.org/tracks/python/exercises/palindrome-products/approaches/nested-for-loop
+[break]: https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops

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

@@ -0,0 +1,5 @@
+for number_a in range(max_factor, min_factor - 1,-1):
+        was_bigger = False
+        for number_b in range(max_factor, number_a - 1, -1):
+            if number_a * number_b >= result:
+                was_bigger = True