notebooks/02_python_structures_exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises module 2 - structuring code\n",
    "----------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2.1 - count elements under a threshold\n",
    "\n",
    "You have obtained the following list of p-values (for example, for the differential expression of different genes between two conditions).  \n",
    "Your objective is to **count the number of p-values under a 0.01 threshold**.\n",
    "\n",
    "> **Hint**: use a **for loop** and **if/else** structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pvalue_list = [1.00535154e-02, 1.22941721e-05, 3.24394930e-02, 8.94679261e+00, 2.98049067e-06, 9.09825669e-05, \n",
    "               3.36853752e+00, 6.20697198e-05, 8.95054597e-01, 5.74710377e-02, 1.89192894e-02, 3.63563356e-05,\n",
    "               3.82493574e-06, 1.22655284e-02, 4.57160772e-05, 2.61223922e-02, 1.14073839e-01, 2.79637984e+00, \n",
    "               7.44443382e-03, 7.08535499e-03, 3.09091266e-06, 2.81705785e-04, 1.20586747e-01, 6.33694191e-01,\n",
    "               7.55028877e+00, 3.73069616e-06, 4.69617882e-01, 1.70625135e-04, 9.83954210e-02, 5.66469758e-06, \n",
    "               2.75980747e+00, 3.25993737e-01, 2.12660436e-03, 9.34716937e-06, 2.07420167e-03, 3.44020352e-06,\n",
    "               4.25232104e-06, 3.96610195e+00, 5.24490100e-04, 1.98963006e-02, 5.54573716e-06, 5.70480881e-01, \n",
    "               2.01699017e+00, 6.62463060e-02, 2.32309217e-01, 4.01324839e+00, 2.26725375e-02, 2.59926751e-03,\n",
    "               1.00813393e-05, 1.70364348e-03, 6.19237350e-05, 3.47402555e-06, 9.39532324e-02, 1.84532725e-06,\n",
    "               3.16213486e-06, 1.62707334e-02, 3.92343499e-06, 4.10585298e-02, 6.42508118e-05, 2.31664292e+00,\n",
    "               2.77091945e-05, 5.27642349e-05, 7.12496815e+00, 1.46001696e-05, 8.44280995e-06, 8.87996594e-01, \n",
    "               2.99942462e+00, 2.00805718e+00, 3.00415760e-04, 7.81960351e+00, 4.23396329e-05, 3.58632396e-06,\n",
    "               9.90978277e-04, 1.20210438e-02, 2.24154701e+00, 1.93838955e-01, 5.80161256e-05, 2.43081401e+00,\n",
    "               9.42302921e-06, 1.05322067e+00, 1.38479328e+00, 3.52249411e-04, 1.42817900e-06, 4.99347373e-04,\n",
    "               5.11977455e-05, 1.04669122e-02, 1.64353735e-04, 2.07534934e-05, 7.85054274e-06, 5.00689158e+00, \n",
    "               9.96207366e-06, 1.14715564e-04, 1.80809025e-06, 9.09612412e-01, 2.82350199e+00, 5.76393770e-02,\n",
    "               4.34199927e-01, 3.17870890e-05, 8.16189380e-05, 8.46454573e-04]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "### Solution:\n",
    "Uncomment and run the cell below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load solutions/solution_21.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "## Exercise 2.2 - exponential growth \n",
    "\n",
    "Imagine a population starting with 1000 individuals.  \n",
    "At each generation the population is multiplied by 1.5. \n",
    "\n",
    " 1. Simulate a few generation. How large is the population after 3 generations?\n",
    " 2. Use a `while` loop to simulate the population until it reaches 10'000 individuals or more.\n",
    "    How many generation does it take?\n",
    " 3. How does the above change if the population starts at 100 individuals? \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "### Solution:\n",
    "Uncomment and run the cell below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load solutions/solution_22.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "## Exercise 2.3 - \"Brave sir Robin\"\n",
    "Consider the following quote from the Monty Python:\n",
    "\n",
    "> `\"Brave Sir Robin ran away. Bravely ran away away. When danger reared it's ugly head, he bravely turned his tail and fled. Brave Sir Robin turned about and gallantly he chickened out...\"`\n",
    "\n",
    "Perform the following tasks:\n",
    "* Build a dictionary whose keys are characters, and whose values correspond to the number of times a character is present in the quote.\n",
    "\n",
    "  > **Hint**: start with a smaller string than the full quote if you want, like `\"rawr!\"`, which should result in\n",
    "  > the dictionary `{'r':2,'a':1,'w':1,'!':1}`\n",
    "  \n",
    "* Loop over your newly built dictionary, and print the number of times each letter occurs.\n",
    "\n",
    "  > **Hint:** use the `.items()` method when looping over the dictionary.\n",
    "\n",
    "<br>\n",
    "\n",
    "**If you have time:**\n",
    "* Modify your code so that the dictionary only contains letters (not any other character),\n",
    "  and that no distinction is made between upper and lower letters.\n",
    "* **Hint:** look at the `.isalpha()` and `.lower()` methods of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quote = (\n",
    "    \"Brave Sir Robin ran away. Bravely ran away away. \"\n",
    "    \"When danger reared it's ugly head, he bravely turned his tail and fled. \"\n",
    "    \"Brave Sir Robin turned about and gallantly he chickened out...\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "### Solution:\n",
    "Uncomment and run the cell below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load solutions/solution_23.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "## Exercise 2.4 - reverse complement\n",
    "\n",
    "Write a function that returns the <a href=\"https://en.wikipedia.org/wiki/Complementarity_(molecular_biology)\">reverse complement</a> of a string containing a DNA sequence.\n",
    "\n",
    "The reverse complement is the inverted sequence (i.e. end to start), where each nucleotide is replaced by its complement.  \n",
    "Complementary nucleotides are `A` and `T`, and `G` and `C`.\n",
    "\n",
    "Here are some examples:\n",
    "* `AATGCC` -> `GGCATT`\n",
    "* `AAAGGC` -> `GCCTTT`\n",
    "* `AAATTT` -> `AAATTT`\n",
    "\n",
    "Test your function with the sequence `ATAGAGCGATCGATCCCTAGCTA`, compare your results with what you can get using <a href=\"http://arep.med.harvard.edu/labgc/adnan/projects/Utilities/revcomp.html\">this online tool</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "### Solution:\n",
    "Uncomment and run the cell below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load solutions/solution_24.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>\n",
    "\n",
    "# Additional exercises\n",
    "--------------------------------\n",
    "\n",
    "## Additional exercise 2.5\n",
    "\n",
    "A little bit of a puzzle:\n",
    "```python\n",
    "def mysterious_function(n):\n",
    "    if n <= 1:\n",
    "        return 1\n",
    "    return n * mysterious_function(n - 1)\n",
    "```\n",
    "\n",
    "<br>\n",
    "\n",
    "1. What does the `mysterious_function` do?\n",
    "2. Write a function that gives the same result, but using a `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "### Solution:\n",
    "Uncomment and run the cell below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load solutions/solution_25.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "## Additional exercise 2.6\n",
    "\n",
    "The <a href=\"https://en.wikipedia.org/wiki/Collatz_conjecture\">Collatz conjecture</a> describes the following procedure:\n",
    "* Start with any positive integer `n`. \n",
    "* Then each term is obtained from the previous term as follows:\n",
    "   * If the previous term is even, the next term is half of the previous term.\n",
    "   * If the previous term is odd, the next term is 3 times the previous term plus 1. \n",
    "\n",
    "The conjecture is that no matter the value of `n`, the sequence will always reach 1.\n",
    "1. Write a function that takes an integer `n` as argument and returns the number of steps\n",
    "   it took to reach `1` following the described procedure.\n",
    "\n",
    "> You can test your function by checking that `13` leads to the following sequence of size 10:\n",
    ">\n",
    ">   13 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1\n",
    "\n",
    "2. How would you account for a case where the conjecture is false (i.e. the sequence never reaches 1)?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "### Solution:\n",
    "Uncomment and run the cell below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load solutions/solution_26.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "## Additional exercise 2.7\n",
    "\n",
    "Write a function that takes a string of mixed letters and digits, and returns a list of the words (groups of letters) and numbers (group of digits) of the string.  \n",
    "For instance, the string `\"Nobody0expects42the2048Spanish1492Inquisition!\"`  \n",
    "should give `[ \"Nobody\" , 0 , \"expects\" , 42 , \"the\" , 2048 , \"Spanish\" , 1492 , \"Inquisition!\" ]`\n",
    "\n",
    "> This exercise can be a tad harder than what it looks like. Don't despair and take your time; you can make it !\n",
    "\n",
    "**Hint:** you can make use of the string method `isdigit()` to determine whether a character is a number or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "### Solution:\n",
    "Uncomment and run the cell below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load solutions/solution_27.py"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}