3_exercise_solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solutions to the exercises\n",
    "\n",
    "There are always different ways of solving a task. Here are some possible solutions for the exercises in the previous notebook, starting with a basic solution that works, as well as more concise, efficient, and elegant approaches. Don't worry if you didn't arrive at the elegant solution yourself, but make sure you understand what is happening there."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1: all the same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# basic solution\n",
    "def all_the_same1(a_list):\n",
    "    # if the list only has 1 or 0 elements, they must be the same:\n",
    "    if len(a_list) <= 1:\n",
    "        return True\n",
    "    # otherwise we check the elements - starting with the first one\n",
    "    elem1 = a_list[0]\n",
    "    # go through all elements and see if they are the same as the first\n",
    "    for e in a_list:\n",
    "        # if the current element isn't the same as the first element, we're done\n",
    "        if e != elem1:\n",
    "            return False\n",
    "    # after we've gone through all elements in the list and we didn't terminate early,\n",
    "    # then apparently they all match and we can return True\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# improved basic solution with a list comprehension\n",
    "def all_the_same2(a_list):\n",
    "    # creates a list with True and False where all need to be True\n",
    "    return all([a == a_list[0] for a in a_list])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# elegant one liner\n",
    "def all_the_same3(a_list):\n",
    "    # set(a_list) gives the unique elements in the list,\n",
    "    # if there are 1 or 0 unique elements, the elements in the original are all the same,\n",
    "    # otherwise the length check evaluates to False\n",
    "    return len(set(a_list)) <= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2: password strength\n",
    "\n",
    "There are several different ways of solving this, but you always need to check all conditions. `any(a_list)` is very helpful. Besides the solution below, you could also check all characters in the password to make sure at least one of them fulfills each `.isdigit()`, `.isupper()`, and `.islower()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# explicit solution\n",
    "def strong_password1(password):\n",
    "    # at least 10 characters\n",
    "    if len(password) < 10:\n",
    "        return False\n",
    "    # can't be all uppercase\n",
    "    if password.upper() == password:\n",
    "        return False\n",
    "    # can't be all lowercase\n",
    "    if password.lower() == password:\n",
    "        return False\n",
    "    # at least one of the characters in the password must be a digit\n",
    "    if not any([c.isdigit() for c in password]):\n",
    "        return False\n",
    "    # passed all checks - good to go\n",
    "    return True\n",
    "\n",
    "# one liner (that stretches over multiple lines for readability - note the extra () around the statement\n",
    "# as otherwise Python would complain about the muliple lines (could also use \\ to escape the new line))\n",
    "def strong_password2(password):\n",
    "    # combine all checks with \"and\"\n",
    "    return ((len(password) >= 10) and \n",
    "            (password.upper() != password) and \n",
    "            (password.lower() != password) and\n",
    "            any([c.isdigit() for c in password]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3: most frequent letter\n",
    "\n",
    "Always try to use as many builtin functions as possible! For example, the string methods `.lower()`, `.isalpha()`, or `.count()` can help here. List and dictionary comprehensions instead of for loops also make your code more efficient.\n",
    "\n",
    "For counting elements in a list you can also import the helper class `Counter` from a standard Python library:\n",
    "```python\n",
    "from collections import Counter\n",
    "```\n",
    "`Counter(a_list)` returns a quasi-dictionary with `{elem_in_a_list: count_of_elem}`. Try it out! But here we stick to solutions without any additional imports."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# basic solution\n",
    "def most_freq_letter1(text):\n",
    "    # transform the text to lower case\n",
    "    text = text.lower()\n",
    "    # count how often each letter occurs (ignoring other characters)\n",
    "    count_dict = {}\n",
    "    for l in text:\n",
    "        if l.isalpha():\n",
    "            # this could also be done with try/except like in the tutorial\n",
    "            if l in count_dict:\n",
    "                count_dict[l] += 1\n",
    "            else:\n",
    "                count_dict[l] = 1\n",
    "    # the naive solution would be to call max(count_dict, key=count_dict.get)\n",
    "    # to get the most frequent letter, but this doesn't assure that ties are resolved correctly\n",
    "    # therefore we first get the frequency of the most frequent letter\n",
    "    freq = max(count_dict.values())\n",
    "    # then select all letters that have this frequency\n",
    "    freq_letters = [l for l in count_dict if count_dict[l] == freq]\n",
    "    # then we return the letter that comes first in the alphabet from this list\n",
    "    return min(freq_letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# improved solution - dictionary comprehension with .count() instead of loop\n",
    "def most_freq_letter2(text):\n",
    "    text = text.lower()\n",
    "    # count how often each letter occurs\n",
    "    # set(a_string) gives the unique letters in the string\n",
    "    count_dict = {l: text.count(l) for l in set(text) if l.isalpha()}\n",
    "    # same as before, just in one line as well\n",
    "    return min([l for l in count_dict if count_dict[l] == max(count_dict.values())])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# elegant one liner\n",
    "def most_freq_letter3(text):\n",
    "    # by giving max as a key the count function called on text.lower(),\n",
    "    # max goes through all the letters in the given alphabet string,\n",
    "    # checks for each letter how often it occurs in the lower case text\n",
    "    # and then returns the first letter with the maximum frequency\n",
    "    return max(\"abcdefghijklmnopqrstuvwxyz\", key=text.lower().count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "597 µs ± 883 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "# %%timeit is a \"magic command\" that lets you measure how long it takes to execute some code\n",
    "# this way we can benchmark the different solutions\n",
    "most_freq_letter1(\"a\" * 1000 + \"b\" * 9000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "93.8 µs ± 617 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "# how much faster do we get by using the dictionary comprehension and more builtin methods?\n",
    "most_freq_letter2(\"a\" * 1000 + \"b\" * 9000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "90 µs ± 598 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "most_freq_letter3(\"a\" * 1000 + \"b\" * 9000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4 (advanced): flatten list\n",
    "\n",
    "This exercise can be nicely solved with a concept called [recursion](https://en.wikipedia.org/wiki/Recursion_(computer_science)). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# solution using recursion\n",
    "def flat_list(a_list):\n",
    "    # this stores the new, flattened list\n",
    "    flattened_list = []\n",
    "    # go through all elements of the given list (if any)\n",
    "    for elem in a_list:\n",
    "        # if the element is a list itself, we need to flatten it\n",
    "        # by calling flat_list again (this is the recursive part)\n",
    "        if type(elem) == list:\n",
    "            # as flat_list always returns as list (might be empty)\n",
    "            # we add these elements to our flattened list by extending it\n",
    "            flattened_list.extend(flat_list(elem))\n",
    "        else:\n",
    "            # if elem is a normal (non-list) element, we just add it to\n",
    "            # the flattened list normally with append\n",
    "            flattened_list.append(elem)\n",
    "    return flattened_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The solution above can also be written in a more concise way using a one line `if-else` statement:\n",
    "\n",
    "```python\n",
    "# full if-else statement\n",
    "if AAA:\n",
    "    variable = XXX\n",
    "else:\n",
    "    variable = YYY\n",
    "# equivalent one liner:\n",
    "variable = XXX if AAA else YYY\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# shorter solution\n",
    "def flat_list(a_list):\n",
    "    flattened_list = []\n",
    "    for elem in a_list:\n",
    "        # one line if-else statement\n",
    "        flattened_list.extend(flat_list(elem) if type(elem)==list else [elem])\n",
    "    return flattened_list"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}