Advanced Exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3b0eafa7-25ef-44ed-8a1d-3b0d7b5a70df",
   "metadata": {},
   "source": [
    "### 2-3\n",
    "A special number, `NaN`, is used to represent the notion of \"undefined\" or \"unrepresentable\". What happens when you attempt to use `NaN` in arithmetic calculations?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fd45294-ae3a-46d7-becd-e546a3bd45ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "nan = float(\"NaN\")\n",
    "1 + nan"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a0b169e-b0d2-47c5-a15e-b88b519deee3",
   "metadata": {},
   "source": [
    "### 2-5\n",
    "What is the deference between the `==` operator and the `is` operator?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5857438-f4be-42de-bdac-3e1234f5f8a7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "156b2fdf-02ca-4bc7-8f0b-12f1d8727b8d",
   "metadata": {},
   "source": [
    "### 2-6\n",
    "You know that the `*` symbol is the operator for multiplication, `+` is addition, `/` is division, etc. Here is a new operator, see if you can find out what it does:\n",
    "* `//` (e.g. `5 // 2`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96495c64-c13e-4e82-b389-61f359b4dde0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "82e78793-61ac-4bd8-bc62-f7a5d741192b",
   "metadata": {},
   "source": [
    "### 2-8\n",
    "Write a program to ask the user for their name, then print out a greeting using their name. You can use the `input()` and `print()` commands."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2dd11af5-b4c5-4d53-b3b8-79f664ee0f0c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cc0b25ca-41e3-4680-9d32-926082584e68",
   "metadata": {},
   "source": [
    "### 2-10\n",
    "What does the `bool()` function do? What input values (strings, numbers) result in `True` and what result in `False`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c72209e-20ec-4f93-b22a-78f9b669e599",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c1814ca7-46cc-4cd2-898f-17cea66afc84",
   "metadata": {},
   "source": [
    "### 3-2\n",
    "What is meant by \"global\" variable? How is a \"global variable\" different from a \"local variable\"? Use a global variable to keep track of how many times `my_fun()` is applied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f46b3cad-68f2-401c-8b5f-775124efdd30",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_fun():\n",
    "    pass # Fix me"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9df499ee-00f3-4214-8acd-f87c01df5d9d",
   "metadata": {},
   "source": [
    "### 3-3\n",
    "Is `my_fun()` in **3-2** above a pure _function_ or a _command_? What's the difference?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27682603-a7ff-4308-aace-81db10979068",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2a4ccc83-2ea1-47c5-a3da-bec2511f7254",
   "metadata": {},
   "source": [
    "### 3-7\n",
    "Write a function `apply()` that accepts a function argument followed by a series of arguments. `apply()` should apply the function to those arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66c6b49e-2fd7-4b25-a3bb-da18d9b0fe6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import getitem\n",
    "\n",
    "def apply(fn, *args):\n",
    "    pass # Fix me\n",
    "\n",
    "assert apply(getitem, [6, 3, 1], 1) == 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b4e2042-84cc-4d8e-8950-5bf0debbeb91",
   "metadata": {},
   "source": [
    "### 3-8\n",
    "Write a function that takes 2 functions as arguments and returns the composition of those 2 functions?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7cd281c-aed2-46a1-ad92-0d1751ad30d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compose(funA, funB):\n",
    "    \"Compose 2 functions that take a single argument into a single function\"\n",
    "    def composed(x):\n",
    "        return _\n",
    "\n",
    "    return composed\n",
    "\n",
    "length_as_string = compose(str, len)\n",
    "assert \"16\" == length_as_string(\"A big hello!!!!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef0a15a2-bb08-44d3-8492-342e5b5ab340",
   "metadata": {},
   "source": [
    "### 4-1\n",
    "Write a function that tests for case-insensitive string equality `str_case_equal()` between 2 strings, then use this in a basic text menu. Prompt the user for a menu item then print some descriptive text or an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb54585a-5c9b-4430-95e5-ee155892169f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def str_case_equal(a, b):\n",
    "    return False # fix me\n",
    "\n",
    "def menu():\n",
    "    selection = input(\">\")\n",
    "    if str_case_equal(\"batman\", selection):\n",
    "        print(\"Nananananana Batman!\")\n",
    "        return\n",
    "    # Extend me"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2b6cb4b-736f-40eb-993b-cf44e881a184",
   "metadata": {},
   "source": [
    "### 4-2\n",
    "Write a function to evaluate the result of 1 round of [Rock, Paper, Scissors](https://en.wikipedia.org/wiki/Rock_paper_scissors) between 2 people."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee149608-09f1-451d-91c4-7e89875ca909",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rock_paper_scissors(player1, player2):\n",
    "    return # Fix me\n",
    "\n",
    "assert \"Rock\" == rock_paper_scissors(\"Rock\", \"scissors\")\n",
    "assert None is rock_paper_scissors(\"rock\", \"rock\")\n",
    "assert \"paper\" == rock_paper_scissors(\"rock\", \"paper\")\n",
    "assert \"Scissors\" == rock_paper_scissors(\"Rock\", \"Scissors\")\n",
    "assert \"rock\" == rock_paper_scissors(\"Scissors\", \"rock\")\n",
    "assert \"Paper\" == rock_paper_scissors(\"Paper\", \"Rock\")\n",
    "assert \"scissors\" == rock_paper_scissors(\"scissors\", \"rock\")\n",
    "assert None is rock_paper_scissors(\"Paper\", \"paper\")\n",
    "assert None is rock_paper_scissors(\"scissors\", \"Scissors\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "196b2ef6-3b1b-4326-8d84-765d7abb6f6e",
   "metadata": {},
   "source": [
    "### 4-3\n",
    "Debug this function called `guard()`. The tests test for correct behaviour."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd1b0a72-f699-404a-b317-9134af06a9b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import truediv\n",
    "\n",
    "def guard(check, default, fn, *args):\n",
    "    if not check:\n",
    "        return fn(*args)\n",
    "    \n",
    "    return default\n",
    "\n",
    "def safe_div(numerator, denominator):\n",
    "    \"Return infinity instead of throwing an exception when a division by zero happens\"\n",
    "    return guard(denominator != 0, float(\"inf\"), truediv, numerator, denominator)\n",
    "\n",
    "assert 2.0 == safe_div(10, 5)\n",
    "assert float(\"inf\") == safe_div(1, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abee27b1-d479-4bee-9121-bf4b2a701a30",
   "metadata": {},
   "source": [
    "### 4-4\n",
    "Write a function, `min3()`, that takes three input numerical arguments and returns the smallest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "838b3339-ad42-42b2-bbc9-3c937e11152c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def min3(a, b, c):\n",
    "    return a # Fix me\n",
    "\n",
    "assert -1 == min3(0, 1, -1)\n",
    "assert 0 == min3(2, 0, 1)\n",
    "assert 100 == min3(100, 101, 102)\n",
    "assert float(\"-inf\") == min3(0, float(\"inf\"), float(\"-inf\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04cff2fd-6ee3-4fee-9570-4783019e6408",
   "metadata": {},
   "source": [
    "### 4-5\n",
    "Extend your `fizzbuzz()` function to also check for multiples of `7`. Multiples of `7` should be replaced by the string \"Wizz\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6eeab19f-5adc-4162-be57-abb90b65b910",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fizzbuzz(n):\n",
    "    pass # Fix me"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53ddf997-c9a5-427b-89a7-d2884dbed48e",
   "metadata": {},
   "source": [
    "### 5-1\n",
    "Explore the [list documentation](https://docs.python.org/3/tutorial/datastructures.html) to find an alternative for the `+=` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c27ed72e-df33-4962-a57d-5eb41127cb63",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8dd30f18-008d-452a-a564-7b54b7a55cc3",
   "metadata": {},
   "source": [
    "### 5-2\n",
    "Explore the [operator library](https://docs.python.org/3/library/operator.html) documentation to find a function that can be used in place of a slice operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ea4419f-52a8-46cb-adc2-2f2db4628603",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9862d0ad-7f83-4b6f-a510-fdd148a1c248",
   "metadata": {},
   "source": [
    "### 5-5\n",
    "\n",
    "Write a function that takes 2 parameters: a string to truncate (`text`), and a maximum length (`max_len`) that checks if `text` is longer than `max_len`, if it is, the string should be\n",
    "truncated and display ellipses (\"...\") as the last 3 characters. The truncated string + the ellipses should\n",
    "fit within `max_len`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "193a979b-6bc5-4c20-9cee-7c76f4c236f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def truncate(text, max_len):\n",
    "    return text\n",
    "\n",
    "assert truncate(\"hello world\", 10) == \"hello w...\", \"Expected: 'hello w...', got: \" + str(truncate('hello world', 10))\n",
    "assert truncate('python', 6) == 'python', \"Expected: 'python', got: \" + str(truncate('python', 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f805d162-25c6-448d-b889-5bc7f2db5976",
   "metadata": {},
   "source": [
    "### 6-1\n",
    "How does a `while` loop differ from a `for`-each loop?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ed99ad8-318a-4c94-af4b-a5ccf14c334c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "53cf255a-d2df-476d-abc5-9b169626c5bb",
   "metadata": {},
   "source": [
    "### 6-5\n",
    "What does the `enumerate()` function do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05132ed5-9d0f-4581-8c26-6f29f37fdb5b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c74cfe16-d35d-444b-9f77-4d8fb1160de4",
   "metadata": {},
   "source": [
    "### 7-2\n",
    "Write a function `filter_map(xs, fn)` that accepts a list (`xs`) and a function (`fn`) as arguments. The `fn` function should return either a value or `None`. When `fn` returns `None` that value should not appear in the output. When it does not return `None` that value should appear in the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79bbfcba-5059-49df-81fb-1fe639395e63",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_map(xs, fn):\n",
    "    pass # Fix me\n",
    "\n",
    "def to_string_odd(a):\n",
    "    if (a % 2) == 1:\n",
    "        return str(a)\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "assert filter_map(range(10), to_string_odd) == [\"1\", \"3\", \"5\", \"7\", \"9\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e68c3e03-a9aa-4876-a3ed-c29a7952c2e2",
   "metadata": {},
   "source": [
    "### 7-5\n",
    "The Hamming distance between two strings of equal length is the number of positions at which the corresponding characters are different. In a more general context, the Hamming distance is one of several string metrics for measuring the _distance_ between two sequences. \n",
    "\n",
    "For example, the Hamming distance between:\n",
    "\n",
    "\"karolin\" and \"kathrin\" is 3.\n",
    "\n",
    "Write a function called \"hamming_distance\" which accepts two strings and returns the calculated hamming distance. If the lengths of the two strings is unequal, return the value `None`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee05ae53-f8ad-42fd-973c-a4a36cd9fadb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def hamming_distance(string1: str, string2: str) -> int: \n",
    "    pass\n",
    "\n",
    "seq1 = \"GATCATAGA\"\n",
    "seq2 = \"CATCATACA\"\n",
    "assert hamming_distance(seq1,seq2) == 2, \"Expected 2, got: \" + str(hamming_distance(seq1,seq2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70e3fa89-9258-4713-8661-efa2f4cfd106",
   "metadata": {},
   "source": [
    "### 8-1\n",
    "\n",
    "You're given a list containing some names and a corresponding list containing their rank by popularity.\n",
    "Write a function that takes a name as its argument, the behaviour of the function depends on 3 conditions:\n",
    "* If the name is in the `names` list and in the top 20 most popular names: Return a 2-tuple containing the name and rank (E.g. if the argument is \"Elise\", your function should return `(\"Elise\", 14)`)\n",
    "* If the name is in the `names` list but not in the top 20 most popular names: Return the name reversed (E.g. if the argument is \"Alexander\", your function should return \"rednaxelA\")\n",
    "* Otherwise, return the name followed by the string `\" is great at Python!\"` (E.g. if the argument is \"Tatiana\", your function should return \"Tatiana is great at Python!\")\n",
    "\n",
    "    <!-- Data from: https://www.behindthename.com/top/lists/belgium -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6cf9ed5a-5e89-47ed-8700-684b0a368725",
   "metadata": {},
   "outputs": [],
   "source": [
    "names = [\"Marie\", \"Lucas\", \"Viktor\", \"Elise\", \"Lotte\", \"Hugo\", \"Emma\", \"Elena\", \"Julia\", \"Maxime\", \"Alexander\", \"Tuur\", \"Nina\", \"James\", \"Bruna\"]\n",
    "ranks = [7,       6,       65,       14,      46,      15,     1,      7,       26,      37,       36,          73,     25,     87,      1228]\n",
    "\n",
    "def baby_name(name):\n",
    "    pass\n",
    "\n",
    "assert baby_name(\"Elise\") == ('Elise', 14), \"Expected ('Elise', 14), got: \" + str(baby_name('Elise'))\n",
    "assert baby_name(\"Alexander\") == 'rednaxelA', \" Expected 'rednaxelA', got: \" + str(baby_name('Alexander'))\n",
    "assert baby_name(\"Tatiana\") == \"Tatiana is great at Python!\", \"Expected 'Tatiana is great at Python!', got: \" + str(baby_name('Tatiana'))\n",
    "assert baby_name(\"Elena\") == ('Elena', 7), \"Expected ('Elena', 7), got: \" + str(baby_name('Elena'))"
   ]
  }
 ],
 "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}