fix final exercises

Author: despadam

11_functional_programming.ipynb

@@ -1582,17 +1582,17 @@
    "source": [
     "### Exercise 1: Transposing a Matrix\n",
     "\n",
-    "Consider a matrix `M` represented row-wise as a list of lists `[[1, 2, 3], [4, 5, 6], [7, 8, 8]]`.\n",
-    "Write a function  that returns the transpose of `M`, the matrix obtained by exchanging rows and columns.\n",
+    "Consider a matrix represented row-wise as a list of lists `[[1, 2, 3], [4, 5, 6], [7, 8, 8]]`.\n",
+    "Write a function  that returns its transpose, the matrix obtained by exchanging rows and columns.\n",
     "\n",
-    "- Example 1: given `M=[[1, 0], [0, 1]]`, the result must be `[[1, 0], [0, 1]]`\n",
-    "- Example 2: given `M=[[1, 2, 3], [4, 5, 6], [7, 8, 8]]` the result must be `[1, 4, 7], [2, 5, 8], [3, 6, 8]]`\n",
+    "- Example 1: given `matrix=[[1, 0], [0, 1]]`, the result must be `[[1, 0], [0, 1]]`\n",
+    "- Example 2: given `matrix=[[1, 2, 3], [4, 5, 6], [7, 8, 8]]` the result must be `[1, 4, 7], [2, 5, 8], [3, 6, 8]]`\n",
     "\n",
     "\n",
     "\n",
     "<div class=\"alert alert-block alert-info\">\n",
     "    <h4><b>Hints</b></h4>\n",
-    "    The <code>zip</code> function behaves similar to a transposition: <code>zip([1,2], [3,4]) = [(1,3), (3,4)])</code>\n",
+    "    The <code>zip</code> function behaves similarly to a transposition: <code>zip([1,2], [3,4]) = [(1,3), (2,4)])</code>\n",
     "<div>\n"
    ]
   },
@@ -1608,12 +1608,12 @@
    "source": [
     "%%ipytest\n",
     "\n",
-    "def solution_exercise1(m: \"list[list[int]]\") -> \"list[list[int]]\":\n",
+    "def solution_exercise1(matrix: list[list[int]]) -> list[list[int]]:\n",
     "    \"\"\"A function that returns the transpose of a given matrix, by using the zip function.\n",
     "    The transpose of a matrix is obtained by swapping the rows and columns of the matrix.\n",
     "\n",
     "    Args:\n",
-    "        m: the initial matrix\n",
+    "        matrix: the initial matrix\n",
     "    Returns:\n",
     "        - the transposed matrix\n",
     "    \"\"\"\n",
@@ -1631,7 +1631,7 @@
    "source": [
     "### Exercise 2: Flattening list of lists\n",
     "\n",
-    "Imagine we receive a list of lists `l` like `[[1, 2], [3, 4]]`. Write a function that converts this list into a `flat` list like `[1, 2, 3, 4]`. \n",
+    "Imagine we receive a list of lists like `[[1, 2], [3, 4]]`. Write a function that converts this list into a `flat` list like `[1, 2, 3, 4]`. \n",
     "\n",
     "<div class=\"alert alert-block alert-info\">\n",
     "    <h4><b>Hints</b></h4>\n",
@@ -1651,11 +1651,11 @@
    "source": [
     "%%ipytest\n",
     "\n",
-    "def solution_exercise2(l: \"list[list[any]]\") -> \"list[any]\":\n",
+    "def solution_exercise2(my_list: list[list[any]]) -> list[any]:\n",
     "    \"\"\"A function that returns a flattened list from a given list of lists, by using funtools.reduce\n",
     "\n",
     "    Args:\n",
-    "        l: the initial list of lists\n",
+    "        my_list: the initial list of lists\n",
     "    Returns:\n",
     "        - the flattened list\n",
     "    \"\"\"\n",
@@ -1673,7 +1673,7 @@
    "source": [
     "### Exercise 3: Counting initials\n",
     "\n",
-    "Given a list `w` of English words, write a function that counts how many words begin with each letter of the English alphabet and returns the result as an **alphabetically sorted** list of tuples `(letter, count)`. We do not distinguish between uppercase and lowercase letters (\"A\" and \"a\" are considered the same).  \n",
+    "Given a list of English words, write a function that counts how many words begin with each letter of the English alphabet and returns the result as an **alphabetically sorted** list of tuples `(letter, count)`. We do not distinguish between uppercase and lowercase letters (\"A\" and \"a\" are considered the same).  \n",
     "\n",
     "\n",
     "<div class=\"alert alert-block alert-info\">\n",
@@ -1702,14 +1702,14 @@
    "source": [
     "%%ipytest\n",
     "\n",
-    "def solution_exercise3(w: list[str]) -> list[(str, int)]:\n",
-    "    \"\"\"A function that counts the number of words from a given list that start with each letter of the alphabet.\n",
-    "    The function should be case insensitive.\n",
+    "def solution_exercise3(words: list[str]) -> list[(str, int)]:\n",
+    "    \"\"\"A function that counts the number of words from a given list that start with each letter of the alphabet, using sorted() and itertools.groupby.\n",
+    "    The function should be case insensitive, using lower() to ensure consistet capitalization.\n",
     "    It should return a list of tuples, where each tuple contains a letter and the number of words that start with that letter.\n",
-    "    This tuple should be sorted in alphabetical order.\n",
+    "    The list of tuples should be sorted in alphabetical order.\n",
     "\n",
     "    Args:\n",
-    "        w: the initial list of words\n",
+    "        words: the initial list of words\n",
     "    Returns:\n",
     "        - the alphabetically sorted list of tuples\n",
     "    \"\"\"\n",
@@ -1726,16 +1726,16 @@
    },
    "source": [
     "### Exercise 4: Counting initials frequency\n",
-    "If you could solve the previous exercise, you now have a list `l` of the form `[('a', 20), ('b', 30), ...]`.\n",
-    "If you cannot, do not worry: you will receive the correct input automatically as `l` inside the function `solution_exercise4`\n",
+    "If you could solve the previous exercise, you now have a list of the form `[('a', 20), ('b', 30), ...]`.\n",
+    "If you could not, do not worry: you will receive the correct input automatically as an argument inside the function `solution_exercise4`.\n",
     "\n",
     "\n",
-    "Write a function that computes the *relative frequency* of each letter in the list `l` and returns a list of tuples `(letter, frequency)`.\n",
+    "Write a function that computes the *relative frequency* of each letter in that list and returns a list of tuples `(letter, frequency)`.\n",
     "\n",
     "\n",
     "<div class=\"alert alert-block alert-info\">\n",
     "    <h4><b>Hints</b></h4>\n",
-    "    The relative frequence of a value <code>a</code> in a list is simply the number of time it appears in that list over the total lenght of the list.\n",
+    "    The relative frequence of a value <code>a</code> in a list is simply the number of times it appears in that list, over the total length of the list.\n",
     "<div>"
    ]
   },
@@ -1751,14 +1751,14 @@
    "source": [
     "%%ipytest\n",
     "\n",
-    "def solution_exercise4(l: \"list[(str, int)]\") -> \"list[(str, float)]\":\n",
+    "def solution_exercise4(my_list: list[(str, int)]) -> list[(str, float)]:\n",
     "    \"\"\"A function that computes the relative frequency of each letter from a given list of tuples.\n",
     "    The relative frequency is calculated as the number of occurrences of a letter in the list, divided by the length of the list.\n",
     "\n",
     "    Args:\n",
-    "        l: the initial list of tuples\n",
+    "        my_list: the initial list of tuples (letter, count) which counts how many words start with each letter\n",
     "    Returns:\n",
-    "        - the list of tuples with the relative frequency of each letter\n",
+    "        - the list of tuples (letter, frequency) with the relative frequency of each letter\n",
     "    \"\"\"\n",
     "\n",
     "    return"
@@ -1806,14 +1806,15 @@
    "source": [
     "%%ipytest\n",
     "\n",
-    "def solution_exercise5(words: \"list[str]\") -> \"list[str]\":\n",
-    "    \"\"\"A function that returns a list of words from a given list of words, that are palindromes.\n",
-    "    A palindrome is a word that reads the same backwards as forward.\n",
+    "def solution_exercise5(words: list[str]) -> list[str]:\n",
+    "    \"\"\"A function that returns a list of words that are palindromes, from a given list of words.\n",
+    "    A palindrome is a word that reads the same forward and backward.\n",
+    "    A word is any string longer than 1 character.\n",
     "\n",
     "    Args:\n",
     "        words: the initial list of words\n",
     "    Returns:\n",
-    "        - the list of palindromes\n",
+    "        - the list of palindrome words\n",
     "    \"\"\"\n",
     "\n",
     "    return"
@@ -1837,7 +1838,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.10"
+   "version": "3.10.13"
   },
   "vscode": {
    "interpreter": {

tutorial/tests/test_11_functional_programming.py

@@ -153,8 +153,8 @@ def test_multiples_of_n(
 #
 
 
-def reference_exercise1(x: List[List[int]]) -> List[List[int]]:
-    return [list(i) for i in zip(*x)]
+def reference_exercise1(matrix: List[List[int]]) -> List[List[int]]:
+    return [list(i) for i in zip(*matrix)]
 
 
 @pytest.mark.parametrize(
@@ -205,10 +205,12 @@ def get_data_exercise3() -> List[str]:
     return words.splitlines()
 
 
-def reference_exercise3(w: List[str]) -> List[Tuple[str, int]]:
+def reference_exercise3(words: List[str]) -> List[Tuple[str, int]]:
     return [
         (k, len(list(v)))
-        for k, v in itertools.groupby(sorted(w, key=lambda x: x[0]), key=lambda x: x[0])
+        for k, v in itertools.groupby(
+            sorted(words, key=lambda x: x[0]), key=lambda x: x[0]
+        )
     ]
 
 
@@ -239,8 +241,8 @@ def test_exercise4(
 #
 
 
-def reference_exercise5(my_list: List[str]) -> List[str]:
-    return list(filter(lambda x: x == x[::-1] and len(x) > 1, my_list))
+def reference_exercise5(words: List[str]) -> List[str]:
+    return list(filter(lambda x: x == x[::-1] and len(x) > 1, words))
 
 
 def test_exercise5(function_to_test: Callable[[List[str]], List[str]]):