From 389fb7a452e0d61d129143286a1c5e82a8d4e6c8 Mon Sep 17 00:00:00 2001 From: Lygerakis Fotios Date: Mon, 27 Mar 2023 18:09:36 +0200 Subject: [PATCH] Add files via upload --- iml_assignment1_solved.ipynb | 598 +++++++++++++++++++++++++++++++++++ 1 file changed, 598 insertions(+) create mode 100644 iml_assignment1_solved.ipynb diff --git a/iml_assignment1_solved.ipynb b/iml_assignment1_solved.ipynb new file mode 100644 index 0000000..6d1b155 --- /dev/null +++ b/iml_assignment1_solved.ipynb @@ -0,0 +1,598 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "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.3" + }, + "colab": { + "provenance": [] + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "whjkuflGLNWu" + }, + "source": [ + "# Fibonacci Solver\n", + "\n", + "The Fibonacci Sequence is the series of numbers:\n", + "\n", + "` 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ... `\n", + "\n", + "The next number is found by adding up the two numbers before it:\n", + "\n", + "the `2` is found by adding the two numbers before it `(1+1)`,\n", + "the `3` is found by adding the two numbers before it `(1+2)`,\n", + "the `5` is `(2+3)`,\n", + "and so on!\n", + "\n", + "## Coding it up in Python\n", + "Just initialize to variables with the first two numbers of the Fibonacci sequence. Then add them up and print the result.\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "p58ac2HULNWv" + }, + "source": [ + "# Starting Point\n", + "first_number = 0\n", + "second_number = 1\n", + "result = first_number + second_number\n", + "\n", + "print(result)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xSyPoS1bLNWy" + }, + "source": [ + "You now need to do this multiple times, so you need a ***loop***\n", + "To use a loop you need to know how many times you want to loop for. \n", + "For now, create a loop that prints **20** numbers (from 0 to 19). To do this in python you can create a ***for loop*** using the `range` function which will run the function for every number in the range.\n", + "(TIP: Python is a ***0 based*** language which means it starts counting from 0 not 1 as a human normally would.)" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tTsWxVxMLNWy" + }, + "source": [ + "for count in range(20):\n", + " print(count)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "INNU9p8zLNW0" + }, + "source": [ + "Now use the loop to compute the first 20 elements of the Fibonacci sequence." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4Hf59jqgLNW1" + }, + "source": [ + "# Starting Point\n", + "first_number = 0\n", + "second_number = 1\n", + "\n", + "for count in range(20):\n", + " result = first_number + second_number\n", + " print(result)\n", + " first_number = second_number\n", + " second_number = result" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bScJ-6tULNW3" + }, + "source": [ + "If you managed it till here great job!\n", + "Is seems to work great so far, but you need to store these numbers so you can reference them when needed." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1VhirrXpLNW3" + }, + "source": [ + "Create an empty ***array*** called `fibonacci` and then append the elements of the sequence to it." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "thTMoVY2LNW3" + }, + "source": [ + "# Starting Point\n", + "first_number = 0\n", + "second_number = 1\n", + "\n", + "fibonacci = []\n", + "\n", + "fibonacci.append(first_number)\n", + "fibonacci.append(second_number)\n", + "\n", + "for count in range(20):\n", + " result = first_number + second_number\n", + " # print(result)\n", + " fibonacci.append(result)\n", + " first_number = second_number\n", + " second_number = result\n", + " \n", + "print(fibonacci)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6nlc_cC7LNW5" + }, + "source": [ + "If everything worked according to the plan, you should be able to access any of the first 20 elements of the Fibonacci sequence at will.\n", + "\n", + "eg `fibonacci[0]` would get us the first item in the array whilst `fibonacci[9]` would get us the tenth item (remember Python is 0 based so you always need to take 1 away from the number you need)" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yEKa7pAuLNW6" + }, + "source": [ + "fibonacci[0]" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "1wbxOVnELNW7" + }, + "source": [ + "fibonacci[9]" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "50FpCM7CLNW9" + }, + "source": [ + "So now you know how to get at the index, you need to know which index values are asked for by the user.\n", + "Lets get some input from the user." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "YIJRBUXWLNW-", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 53 + }, + "outputId": "aaadcdb4-2317-4b63-c306-3256393a1875" + }, + "source": [ + "input()" + ], + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'2'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 12 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Get the first index from the user" + ], + "metadata": { + "id": "5Vp9iO2r2e2S" + } + }, + { + "cell_type": "code", + "source": [ + "first_index = input()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Zj6mnXCI2mNo", + "outputId": "8404c9dd-b5f0-42ec-97bd-d57abebafbed" + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Get the second index from the user" + ], + "metadata": { + "id": "9LDXbzP02rFa" + } + }, + { + "cell_type": "code", + "metadata": { + "id": "wqbTuR2TLNXA", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "66aecb44-52c6-44f3-95a7-140c1dce6fe1" + }, + "source": [ + "second_index = input()" + ], + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Print the received inputs and their types" + ], + "metadata": { + "id": "EK9FMjJV22x9" + } + }, + { + "cell_type": "code", + "metadata": { + "id": "xfy81HrsLNXC", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "fd3d4b7d-88c7-4e1e-9486-3a0718dfa737" + }, + "source": [ + "print(first_index)\n", + "print(type(first_index))\n", + "print(second_index)\n", + "print(type(second_index))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2\n", + "\n", + "2\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ttb_0MejLNXE" + }, + "source": [ + "The value received from input will be treated as a string type, you need to convert this to a number so python knows to treat it as one." + ] + }, + { + "cell_type": "code", + "source": [ + "first_index = int(first_index)\n", + "second_index = int(second_index)" + ], + "metadata": { + "id": "RwVoHTLn6QvB" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Print the type of the transformed variables." + ], + "metadata": { + "id": "pxKx8gKy2-eh" + } + }, + { + "cell_type": "code", + "source": [ + "type(first_index)\n", + "type(second_index)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dN_EzHKr3GmO", + "outputId": "c45cdbad-5e51-457a-83d5-57e92e2b44c4" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "int" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CRuAEA7KLNXE" + }, + "source": [ + "Now you have all the parts you need to make this work. \n", + "\n", + "* The user should be prompted \"How many results would you like?\"\n", + "* The program should read the users preference, e.g. 20, and then compute the list of elements up to this number.\n", + "* Then the program should ask the user for 2 indexes within the list of the calculated Fibonacci sequence\n", + "* Finally it should print the summation of their values.\n", + "\n", + "Time to put it together:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ukW0WUA7LNXE", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "f1d134d8-61f7-4f93-a54b-d63dffe08964" + }, + "source": [ + "# Starting Point\n", + "first_number = 0\n", + "second_number = 1\n", + "\n", + "fibonacci = []\n", + "\n", + "fibonacci.append(first_number)\n", + "fibonacci.append(second_number)\n", + "\n", + "print(\"##### GENERATING FIBONACCI LIST #####\")\n", + "fib_range = int(input(\"How many results would you like?\"))\n", + "for count in range(fib_range-2):\n", + " result = first_number + second_number\n", + " # print(result)\n", + " fibonacci.append(result)\n", + " first_number = second_number\n", + " second_number = result\n", + "\n", + "print(\"##### COMPLETED MAKING FIBONACCI LIST #####\")\n", + "\n", + "\n", + "first_index = int(input(\"Please enter the first number you require?\"))\n", + "second_index = int(input(\"Please enter the second number you require?\"))\n", + "\n", + "print(\"##### GETTING RESULT #####\")\n", + "final_answer = fibonacci[first_index-1] + fibonacci[second_index-1]\n", + "print(\"\\n\\nThe answer is:\\n\\n{}\".format(final_answer))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "##### GENERATING FIBONACCI LIST #####\n", + "How many results would you like?10\n", + "##### COMPLETED MAKING FIBONACCI LIST #####\n", + "Please enter the first number you require?10\n", + "Please enter the second number you require?9\n", + "##### GETTING RESULT #####\n", + "\n", + "\n", + "The answer is:\n", + "\n", + "55\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Finally plot the first 30 elements of the Fibonacci sequence using matplotlib" + ], + "metadata": { + "id": "qqMN0OEjEyPN" + } + }, + { + "cell_type": "code", + "metadata": { + "id": "edzR_wahLNXG", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "outputId": "bb9ad5f3-811d-4687-adb0-432d3ed72ab9" + }, + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(fibonacci)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 13 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Compute the Fibonacci sequence recursively" + ], + "metadata": { + "id": "AA67da2KzQnL" + } + }, + { + "cell_type": "code", + "source": [ + "def fibonacci_recursive(n):\n", + " if n < 2:\n", + " return n\n", + " return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)" + ], + "metadata": { + "id": "jJppjtZAzT80" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(\"##### GENERATING FIBONACCI LIST #####\")\n", + "fib_range = int(input(\"How many results would you like?\"))\n", + "for i in range(fib_range):\n", + " print(fibonacci_recursive(i))" + ], + "metadata": { + "id": "1GDrTgOhz7TM", + "outputId": "c1007637-9156-417d-f973-77a3577857a2", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "##### GENERATING FIBONACCI LIST #####\n", + "How many results would you like?20\n", + "0\n", + "1\n", + "1\n", + "2\n", + "3\n", + "5\n", + "8\n", + "13\n", + "21\n", + "34\n", + "55\n", + "89\n", + "144\n", + "233\n", + "377\n", + "610\n", + "987\n", + "1597\n", + "2584\n", + "4181\n" + ] + } + ] + } + ] +} \ No newline at end of file