Py_Project_1_due_1020.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xq__bChjD04e"
      },
      "source": [
        "# Python Assignment 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y7j2V0UDMYLG"
      },
      "source": [
        "⏱⏱⏱**Due: 10/20/2024 11:59:59 PM** ⏱⏱⏱\n",
        "\n",
        "Submit this notebook file and upload it to your git repo. Include a link to your git repo while submitting this file to Brightspace.\n",
        "\n",
        "You are not allowed to use chatgpt or any LLM in this assignment.\n",
        "Cooperation is allowed and encouraged; however, you must write up and submit your own work. If you cooperate with others, you must list their names here."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SUS30Ew9D04n"
      },
      "source": [
        "Total points: 100 (equivalent to 20 points after conversion)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b_bgT3b2GYTB"
      },
      "source": [
        "## 0. Data Types, Structures, Indexing, and Slicing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6yI1Jt57IwV2"
      },
      "source": [
        "Read the lecutre note as well as [this page](https://www.geeksforgeeks.org/mutable-vs-immutable-objects-in-python/) and [this page](https://www.geeksforgeeks.org/difference-between-shallow-and-deep-copy-of-a-class/). Complete the following questions.\n",
        "\n",
        "(5 points) Give some examples (at least 2) of mutable objects in Python.\n",
        "\n",
        "***Answer:***\n",
        "\n",
        "### list1 = [1, 2, 4, 6, 8]\n",
        "\n",
        "### dictionary1 = {\"PetType\": \"Dog\" , \"PetName\": \"bingo\", \"PetCost\": 250};\n",
        "\n",
        "### set1 = {11, 12, 13, 14, 15}\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "(5 points) Give some examples (at least 2) of immutable objects in Python.\n",
        "\n",
        "***Answer:***\n",
        "\n",
        "### tuple1 = (1, 3, 5, 7, 9)\n",
        "\n",
        "### boolean1 = True\n",
        "\n",
        "### string1 = \"AMS 595 is a programming expository class\"\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "(10 points) State the differences between assignment, shallow copy, and deep copy. Any reasonable answer will get full credit.\n",
        "\n",
        "***Answer:***\n",
        "\n",
        "\n",
        "---\n",
        "### Given a list: A = [\"man\", 100, 200, \"woman\", 500]\n",
        "\n",
        "### Assignment is when the list is stored (or assigned) to the variable name \"A\". 'A' could be any name. \n",
        "\n",
        "### Shallow copy: Assume you wanted to duplicate 'A' and assign the duplicate to be \"B\", when changes are made in \"B\", it reflects in 'A'. Although, it is a fast copy, shallow copy stores the references of objects to the original memory address.\n",
        "\n",
        "### Deep copy: Unlike shallow copy, deep copy is slow but does not store to the original memory address (A), so changes made in \"B\" would not reflect in 'A'. More recursive copies can be made without concern of original memory address being affected. \n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OA8DxcrrGqZD"
      },
      "source": [
        "(10 points) Using string methods find() and rfind(), find the index of the first digit (i.e. 0) and the index of the last digit (5) in the string below. Then, using string slicing, extract the number (i.e. 0.595595) from this string and convert the extracted value to a floating point number. Print out this float to the console."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 279,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The extracted number is 0.595595 and its type is <class 'float'> \n",
            "\n",
            "index of first digit is:  43\n",
            "index of last digit 5 is:  50\n"
          ]
        }
      ],
      "source": [
        "text = \"F-DGFDDSFGFD-CFDSHdstgfdfe: tfsd  aaa bdsf 0.595595 fdsgfdbc\"\n",
        "\n",
        "import re\n",
        "\n",
        "index_firstDigit = text.find('0')        # result: the index of the first digit is 43\n",
        "index_lastoccurence_of_5 = text.rfind('5')    # result: the index of the last digit is 50\n",
        "\n",
        "slice_string = re.split(r\" \", text)  # slice the string using space \n",
        "for item in slice_string:\n",
        "    item = item.strip()   # remove all the quotation marks\n",
        "    if re.findall(r\"[0-9]\", item):   # this will only return any number in the sliced string\n",
        "        item = float(item)    # convert the extracted value to a floating point\n",
        "\n",
        "        print(f\"The extracted number is {item} and its type is {type(item)} \\n\")\n",
        "\n",
        "\n",
        "\n",
        "print('index of first digit is: ', index_firstDigit)\n",
        "print('index of last digit 5 is: ', index_lastoccurence_of_5)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cnCljYgpD04p"
      },
      "source": [
        "## 1. Conditional Statements\n",
        "\n",
        "(10 points)\n",
        "Translate the following MATLAB code into Python using `if-elif-else`.\n",
        "```\n",
        "n = input('Enter a number: ');\n",
        "\n",
        "switch n\n",
        "    case -1\n",
        "        disp('negative one')\n",
        "    case 0\n",
        "        disp('zero')\n",
        "    case 1\n",
        "        disp('positive one')\n",
        "    otherwise\n",
        "        disp('other value')\n",
        "end\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "collapsed": true,
        "id": "9d8vl5zjD04q"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "zero\n"
          ]
        }
      ],
      "source": [
        "# Solution\n",
        "\n",
        "n = int(input('Enter a number: '))\n",
        "\n",
        "if n == -1:\n",
        "    print('negative one')\n",
        "elif n == 0:\n",
        "    print('zero')\n",
        "elif n == 1:\n",
        "    print('positive one')\n",
        "else:\n",
        "    print('other value')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sW9XiUPpD04s"
      },
      "source": [
        "## 2. While Loops\n",
        "\n",
        "(10 points) Write a Python program that calculates the factorial of a given number (you can assume an positive integer) using a while loop. Display the result to the console."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "test case for 17! = 355687428096000\n",
            "test case for 13! = 6227020800\n"
          ]
        }
      ],
      "source": [
        "# Solution\n",
        "\n",
        "def factorial_func(n):\n",
        "    if n == 0:\n",
        "        return 1\n",
        "    while n < n + 1:\n",
        "        return n * factorial_func(n - 1)\n",
        "\n",
        "\n",
        "# test cases\n",
        "# n = 17, Output: 355687428096000\n",
        "# n = 13, Output: 6227020800\n",
        "\n",
        "\n",
        "# Test \n",
        "print('test case for 17! =', factorial_func(17))\n",
        "print('test case for 13! =', factorial_func(13))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZQ5SVMq6D04w"
      },
      "source": [
        "## 3. Functions\n",
        "\n",
        "(10 points) Write a function that determines if a number is prime."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6rGP5G3_D04x",
        "outputId": "00df2d17-b697-4146-968f-be4fa7cc3ba3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "def is_prime(n):\n",
        "    # set the exception case\n",
        "    if n < 0:\n",
        "        return print(f\"The prime of {n} is complex\")\n",
        "    # set base cases\n",
        "    elif n == 2 or n == 3:\n",
        "        return True\n",
        "    # set the criteria for NONE prime numbers (even and odd numbers)\n",
        "    elif n ==1 or n % 2 == 0 or n % 3 == 0:\n",
        "        return False\n",
        "    # others are prime number\n",
        "    else:\n",
        "        return True\n",
        "\n",
        "\n",
        "\n",
        "# test cases\n",
        "print(is_prime(2))      # Output: True\n",
        "print(is_prime(10))     # Output: False\n",
        "print(is_prime(17))     # Output: True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Further TEST\n",
        "# All prime numbers less than 100\n",
        "\n",
        "prime_num = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n",
        "\n",
        "new_ = [ ]\n",
        "for i in prime_num:\n",
        "    if is_prime(i) == True:   # test prime\n",
        "        new_.append(i)   # only store numbers that are prime\n",
        "\n",
        "# compare the original prime numbers and new_ tested prime numbers, then\n",
        "# return FALSE is there exist a number that is not counted as prime\n",
        "new_ == prime_num"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z6qg-fpQD04u"
      },
      "source": [
        "## 4. List Comprehension\n",
        "\n",
        "(10 points) Write a Python function called `prime_factors` that takes a relatively small integer as input and returns a list of its distinct prime factors. The function should use list comprehension to generate the list of distinct prime factors. You may use the function is_prime() defined in Q3.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "id": "2hSCjYlOD04v",
        "outputId": "1024d2e2-7d24-4e65-9529-e5a82d2a3211"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2, 3, 5]\n",
            "[2, 7]\n",
            "[2, 3, 11]\n",
            "[2, 29]\n"
          ]
        }
      ],
      "source": [
        "def prime_factors(n):\n",
        "    # List comprehension: Get prime numbers less than 30\n",
        "    prime_ = [i for i in range(n+1) if is_prime(i) == True]\n",
        "                                                                    # Without List Comprehension\n",
        "                                                                    # prime_ = [ ]\n",
        "                                                                    # for i in range(1, n+1):\n",
        "                                                                        # print(i)\n",
        "                                                                    #    if is_prime(i) == True:\n",
        "                                                                    #        prime_.append(i) \n",
        "    # List comprehension: Get the prime factors of 30\n",
        "    final_prime = [j for j in prime_ if n%j == 0]                                                        \n",
        "    \n",
        "                                                                    # Without List Comprehension\n",
        "                                                                    # final_prime = [ ]\n",
        "                                                                    # for j in prime_:\n",
        "                                                                    #    if n % j == 0:\n",
        "                                                                    #       final_prime.append(j)\n",
        "        \n",
        "    \n",
        "    return final_prime\n",
        "\n",
        "\n",
        "# test cases\n",
        "print(prime_factors(30))  # Output: [2, 3, 5]\n",
        "print(prime_factors(56))  # Output: [2, 7]\n",
        "print(prime_factors(198))  # Output: [2, 3, 11]\n",
        "print(prime_factors(464))  # Output: [2, 29]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dw4kZZCiD040"
      },
      "source": [
        "## 5. Recursive Functions\n",
        "(25 points) Write a function that uses recursion to generate the $n$th row of the Pascal's triangle.\n",
        "```\n",
        "              1\n",
        "           1     1\n",
        "        1     2     1\n",
        "      1    3     3     1\n",
        "   1    4     6     4    1\n",
        "1     5    10    10    5    1\n",
        "...\n",
        "...\n",
        "...\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1, 5, 10, 10, 5, 1,  \n"
          ]
        }
      ],
      "source": [
        "def pascal(n, r):\n",
        "    # exclude or stop when r < 0\n",
        "    if r<0:\n",
        "        return ' '\n",
        "    else:\n",
        "        # get helper function: factorial calculation\n",
        "        def factorial(k):\n",
        "            if k ==0 or k == 1:\n",
        "                return 1\n",
        "            else:\n",
        "                return k * factorial(k-1) \n",
        "            \n",
        "        # pascal: using combination formula\n",
        "        pascals_number = factorial(n) / ( factorial(r) * factorial(n-r) )\n",
        "        print(int(pascals_number), end = \", \")\n",
        "        \n",
        "    return pascal(n, r-1)\n",
        "\n",
        "print(pascal(5,5))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eZytgm0qD041"
      },
      "source": [
        "Rewrite the above function using only `while` or `for` loops instead of recursion."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1, 5, 10, 10, 5, 1]\n"
          ]
        }
      ],
      "source": [
        "# Solution (using for loop)\n",
        "\n",
        "def pascal_by_loops(m):\n",
        "    \n",
        "    # deal with negative numbers\n",
        "    if m < 1:\n",
        "        return \"Factorial of negative number is undefined (but gives a complex number)\"\n",
        "    \n",
        "    n = m - 1\n",
        "\n",
        "    # helper function: calculating factorial recurssively. n! = n(n-1)(n-2)...(3)(2)(1)\n",
        "    def factorial_rec(k):\n",
        "        if k == 0 or k == 1: # base case\n",
        "            return 1\n",
        "        else:\n",
        "            return k * factorial_rec(k-1) # recursion\n",
        "\n",
        "    # store the result\n",
        "    result_list = [ ]\n",
        "    \n",
        "    # use the binomial formula: nCr = n! / (r! * (n-r)! )\n",
        "    for r in range(0, n+1):\n",
        "        binomial_formular =  factorial_rec(n) / (factorial_rec(r) * factorial_rec(n-r))\n",
        "        \n",
        "        # store the result as integers\n",
        "        result_list.append(int(binomial_formular))\n",
        "\n",
        "    return result_list\n",
        "\n",
        "\n",
        "\n",
        "print(pascal_by_loops(6))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HvHD6QHzVo9I"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "My [GitHub Link](https://github.com/Benjamin-compute/Python-Project-1/tree/main)\n",
        "\n",
        "\n",
        "（5 points) good coding practice and properly submitting your work to GitHub."
      ]
    }
  ],
  "metadata": {
    "anaconda-cloud": {},
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "base",
      "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"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}