2_exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "Please solve the following exercises to make sure you understand everything from the Python basics tutorial.\n",
    "\n",
    "The solutions can be found in the next notebook, but you should really try to solve all exercises yourself before looking! ;-)\n",
    "\n",
    "#### assert statements\n",
    "\n",
    "For all exercises there are some tests provided as a quick check if you solved the exercise correctly. In software development it is good practice to test all your code rigorously, usually with so called \"unit tests\", to make sure your code also works for possible edge cases. The tests provided here are a bit simpler than regular unit tests, relying instead on simple assert statements. An assert statement is a one liner that raises an `AssertionError` if e.g. a function does not return the expected output for some input:\n",
    "```python\n",
    "assert something that should evaluate to True, \"Error message displayed otherwise\"\n",
    "```\n",
    "Make sure that for the functions you write in the exercises, all the assert tests pass, otherwise you're not done!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "Python is case sensitive",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-d4e42cd345c6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Python should know basic math\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# if it doesn't pass, you'll get an error and the code stops there\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0;34m\"Hello\"\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Python is case sensitive\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m: Python is case sensitive"
     ]
    }
   ],
   "source": [
    "# if the assert test passes, you don't see anything\n",
    "assert 1 + 1 == 2, \"Python should know basic math\"\n",
    "# if it doesn't pass, you'll get an error and the code stops there\n",
    "assert \"Hello\" == \"hello\", \"Python is case sensitive\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1: all the same?\n",
    "\n",
    "Check if all elements in the given list are the same.\n",
    "\n",
    "**Input:** A list with some elements.\n",
    "\n",
    "**Output:** True, if all elements are the same; False if there is at least one element different from the others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_the_same(a_list):\n",
    "    # write code here to return True if all elements are the same, False otherwise\n",
    "    return False\n",
    "\n",
    "# some basic tests with assert statements\n",
    "assert all_the_same([1, 1, 1]) == True, \"all the same\"\n",
    "assert all_the_same([1, 2, 1]) == False, \"some different\"\n",
    "assert all_the_same(['a', 'a', 'a']) == True, \"all the same - letters\"\n",
    "assert all_the_same([]) == True, \"no elements = the same elements\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2: password strength\n",
    "\n",
    "Check if a given password fulfills certain conditions to be considered strong enough:\n",
    "- contains at least 10 characters\n",
    "- contains at least one lower case letter\n",
    "- contains at least one upper case letter\n",
    "- contains at least one digit.\n",
    "\n",
    "**Input:** A string with a password. You are assured that it does not contain any whitespace.\n",
    "\n",
    "**Output:** True if the password fulfills all the above conditions, False otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def strong_password(password):\n",
    "    # check if the password fulfills all conditions and return True or False\n",
    "    return False\n",
    "\n",
    "# some basic tests with assert statements\n",
    "assert strong_password('A1213pokl') == False, \"to short\"\n",
    "assert strong_password('bAse730onE') == True, \"good password\"\n",
    "assert strong_password('asasasasasasasaas') == False, \"only lowercase letters\"\n",
    "assert strong_password('QWERTYqwerty') == False, \"no digits\"\n",
    "assert strong_password('123456123456') == False, \"no letters\"\n",
    "assert strong_password('QwErTy911poqqqq') == True, \"good password\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3: most frequent letter\n",
    "\n",
    "Find and return the most frequent letter in a given string of letters and other symbols. \n",
    "\n",
    "Casing should be ignored (i.e. `\"A\" == \"a\"`) and the returned letter should be in lower case. Make sure you do not count punctuation symbols, digits, or whitespaces - only letters.\n",
    "\n",
    "If you have two or more letters with the same frequency, then return the letter which comes first in the latin alphabet. For example -- \"one\" contains \"o\", \"n\", \"e\" only once, so return \"e\".\n",
    "\n",
    "**Input:** The string that should be analyzed.\n",
    "\n",
    "**Output:** The most frequent letter in lower case as a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def most_freq_letter(text):\n",
    "    # write code here to return the right letter from the given text\n",
    "    return \"a\"\n",
    "\n",
    "# print the output of your function for \"Hello World!\"\n",
    "print(\"Example:\")\n",
    "print(most_freq_letter(\"Hello World!\"))\n",
    "\n",
    "# some basic tests with assert statements\n",
    "assert most_freq_letter(\"Hello World!\") == \"l\", \"Hello test\"\n",
    "assert most_freq_letter(\"How do you do?\") == \"o\", \"O is most wanted\"\n",
    "assert most_freq_letter(\"One\") == \"e\", \"All letter only once.\"\n",
    "assert most_freq_letter(\"Oops!\") == \"o\", \"Don't forget about lower case.\"\n",
    "assert most_freq_letter(\"AAaooo!!!!\") == \"a\", \"Only letters.\"\n",
    "assert most_freq_letter(\"abe\") == \"a\", \"The First.\"\n",
    "# see how efficient your function is - can it handle a string with 10k letters?\n",
    "print(\"Start the long test\")\n",
    "assert most_freq_letter(\"a\" * 1000 + \"b\" * 9000) == \"b\", \"Long.\"\n",
    "print(\"The local tests are done.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4 (advanced): flatten list\n",
    "\n",
    "Lists can be nested, i.e., you can have a list that itself contains another list. Here we want to flatten such nested lists, i.e., get all elements in a single list.\n",
    "\n",
    "**Input:** A possibly nested list, i.e., a list that can have other lists inside it.\n",
    "\n",
    "**Output:** A flattened list with the same elements as the input list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flat_list(a_list):\n",
    "    # some code here to create a flattened version of the list\n",
    "    return a_list\n",
    "\n",
    "assert flat_list([1, 2, 3]) == [1, 2, 3], \"flat list\"\n",
    "assert flat_list([[1, 2, 3]]) == [1, 2, 3], \"single nested list\"\n",
    "assert flat_list([]) == [], \"empty list\"\n",
    "assert flat_list([[], [[]]]) == [], \"empty nested list\"\n",
    "assert flat_list([[1, 2, [], 3]]) == [1, 2, 3], \"empty additional list\"\n",
    "assert flat_list([1, [2, 2, 2], 4]) == [1, 2, 2, 2, 4], \"list with the same elements\"\n",
    "assert flat_list([[[2]], [4, [5, 6, [6], 6, 6, 6], 7]]) == [2, 4, 5, 6, 6, 6, 6, 6, 7], \"very nested\"\n",
    "assert flat_list([-1, [1, [-2], 1], -1]) == [-1, 1, -2, 1, -1], \"symmetric\""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}