cheatsheet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Cheat Sheet](cheatsheet.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"><p>This notebook is meant as a intermediate step for your transition from the strongly-guided coding environment in Datacamp to the \"wilderness\". Solving the tasks in this notebook should be possible solely with the knowledge from Datacamp.</p>\n",
    "\n",
    "<p>On the other hand, the solutions you will have prepared in this notebook, might serve as <em>starting points</em> or <em>ingredients</em> for your solution of the more sophisticated image analysis tasks of the second week of the course.</p></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">In some rare cases you might be asked for a kernel when running cells in a Jupyter notebook. If so, click \"Python environments\" and then \"Python 3.12.2\".</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**[Task 1.]()** Suppose that we have two numpy arrays given:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([ 1,  2, 3, 4, 5])\n",
    "B = np.array([-2, -1, 0, 1, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the element-wise sum of the two arrays `A` and `B` without using loops:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**[Task 2.]()** Suppose that we have the following numpy array given:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([1, 2, 3, 7, 2, 9, 8, 3, 3, 7, 2, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the number of values in `A` larger than `4` without using loops!\n",
    "\n",
    "To do that, *first* generate a boolean array `B` which contains `True` for values larger than `4` and `False` otherwise (see the Exercise *\"Compare arrays\"* from Chapter 3 *\"Logic, Control Flow and Filtering\"* in the Datacamp course *\"Intermediate Python\"*), then use `B.sum()` to count the number of `True` values!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**[Task 3.]()** Suppose that you have two boolean arrays given:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [True, False, True, False]\n",
    "B = [False, True, True, False]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without using loops, compute a list `C` so that `C[idx]` is `True` if and only if `A[idx]` and `B[idx]` are both `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you do not know how to approach the task, see the Exercise *\"Boolean operators with NumPy\"* from Chapter 3 *\"Logic, Control Flow and Filtering\"* in the Datacamp course *\"Intermediate Python\"*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**[Task 4.]()** Suppose that you have a list of numbers given:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [13, 18, 8, 11, 14, 9, 4, 10, 12, 7, 5, 16, 19, 6, 15, 17]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the smallest item in `A`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**[Task 5.]()** Now, instead, compute *the index* of the smallest item in `A`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**[Task 6.]()** Suppose that you have the following list given:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This list can be split into two parts, like for example\n",
    "- `[1, 2, 3, 4]` and `[5, 6, 7, 8, 9, 10, 11, 12]`, or\n",
    "- `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]` and `[12]`.\n",
    "\n",
    "There are overall 11 combinations of splitting `A` into two parts like that, if neither of the parts is empty.\n",
    "\n",
    "Write a loop which prints all those combinations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**[Task 7.]()** Write a re-usable function `truncate_list` that takes two parameters: a list `A` and a value `num`, that is the number of elements after which the list shall be truncated. The function should return the truncated list, i.e. the first `num` elements of the list `A`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def truncate_list(A, num):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Afterwards, use the function `truncate_list` defined above to obtain the list `A` truncated after 3 elements. We call that truncated list `A3`. Print the *sum* and the *product* of the elements in the truncated list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A3 = truncate_list(A, 3)\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The correct result for `A3` is `[1, 2, 3]` and 6 is both the sum and product of the elements."
   ]
  }
 ],
 "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}