Diya_Gupta_Assignment_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Solving these exercises will help make you a better programmer. Solve them in order, because each solution builds scaffolding, working code, and knowledge you can use on future problems. Read the directions carefully, and have fun!"
      ],
      "metadata": {
        "id": "rMNaoJBIn0eW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Fork the repository and make a copy of this notebook and rename it as your name_Assignment1\n",
        "2. Generate a pull request as taught to you in the GitHub Session. The pull request message should also be yourname_Assignment1\n",
        "\n"
      ],
      "metadata": {
        "id": "dtdJ1pURn--h"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Orientation\n",
        "1. This code notebook is composed of cells. Each cell is either text or Python code.\n",
        "2. To run a cell of code, click the \"play button\" icon to the left of the cell or click on the cell and press \"Shift+Enter\" on your keyboard. This will execute the Python code contained in the cell. Executing a cell that defines a variable is important before executing or authoring a cell that depends on that previously created variable assignment.\n",
        "3. Each assert line is both an example and a test that tests for the presence and functionality of the instructed exercise."
      ],
      "metadata": {
        "id": "Y1Lrvy8eonkb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Outline\n",
        "1. Each cell starts with a problem statement that describes the\n",
        "exercise to complete.\n",
        "2. Underneath each problem statement, learners will need to write code to produce an answer.\n",
        "3. The assert lines test to see that your code solves the problem appropriately.\n",
        "4. Do not alter or delete the assertion tests, since those are providing automated testing.\n",
        "5. Many exercises will rely on previous solutions to be correctly completed\n",
        "6. The print(\"Exercise is complete\") line will only run if your solution passes the assertion test(s)\n",
        "7. Be sure to create programmatic solutions that will work for all inputs:\n",
        "For example, calling the is_even(2) returns True, but your function should work for all even numbers, both positive and negative."
      ],
      "metadata": {
        "id": "egsBMww1o-Kw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example problem:\n",
        "# Uncomment the line below and run this cell.\n",
        "# The hashtag \"#\" character in a line of Python code is the comment character.\n",
        "doing_python_right_now = True\n",
        "\n",
        "# The lines below will test your answer. If you see an error, then it means that your answer is incorrect or incomplete.\n",
        "assert doing_python_right_now == True, \"If you see a NameError, it means that the variable is not created and assigned a value. An 'Assertion Error' means that the value of the variable is incorrect.\"\n",
        "print(\"Exercise 0 is correct\") # This line will print if your solution passes the assertion above."
      ],
      "metadata": {
        "id": "wn8-c0_hppDZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "36bffe8f-c187-4110-b734-dc2988760428"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 0 is correct\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 1\n",
        "# On the line below, create a variable named on_mars_right_now and assign it the boolean value of False\n",
        "on_mars_right_now= False\n",
        "assert on_mars_right_now == False, \"If you see a Name Error, be sure to create the variable and assign it a value.\"\n",
        "print(\"Exercise 1 is correct.\")"
      ],
      "metadata": {
        "id": "b-U50lKCp-bF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f7758c02-c894-42cf-cbd0-2e11d271d90a"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 1 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 2\n",
        "# Create a variable named fruits and assign it a list of fruits containing the following fruit names as strings:\n",
        "# mango, banana, guava, kiwi, and strawberry.\n",
        "fruits = ['mango','banana','guava','kiwi','strawberry']\n",
        "assert fruits == [\"mango\", \"banana\", \"guava\", \"kiwi\", \"strawberry\"], \"If you see an Assert Error, ensure the variable contains all the strings in the provided order\"\n",
        "print(\"Exercise 2 is correct.\")"
      ],
      "metadata": {
        "id": "m_7w5CKtqDGY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "76efd92d-b844-4930-ba8f-928fd18c05f6"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 2 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 3\n",
        "# Create a variable named vegetables and assign it a list of fruits containing the following vegetable names as strings:\n",
        "# eggplant, broccoli, carrot, cauliflower, and zucchini\n",
        "vegetables=['eggplant','broccoli','carrot','cauliflower','zucchini']\n",
        "\n",
        "assert vegetables == [\"eggplant\", \"broccoli\", \"carrot\", \"cauliflower\", \"zucchini\"], \"Ensure the variable contains all the strings in the provided order\"\n",
        "print(\"Exercise 3 is correct.\")"
      ],
      "metadata": {
        "id": "13W-B4Z0qIQD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ed4436a5-f701-4a0e-d532-15ed56c841f9"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 3 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# List Operations\n",
        "Recommend finding and using built-in Python functionality whenever possible.\n",
        "Google any syntax that you do not know.\n"
      ],
      "metadata": {
        "id": "tfyYtxDxqUMY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 5\n",
        "# Given the following assigment of the list of fruits, add \"tomato\" to the end of the list.\n",
        "fruits = [\"mango\", \"banana\", \"guava\", \"kiwi\", \"strawberry\"]\n",
        "fruits.insert(5,\"tomato\")\n",
        "\n",
        "\n",
        "assert fruits == [\"mango\", \"banana\", \"guava\", \"kiwi\", \"strawberry\", \"tomato\"], \"Ensure the variable contains all the strings in the right order\"\n",
        "print(\"Exercise 5 is correct\")"
      ],
      "metadata": {
        "id": "vHrZE8u-qLn0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "02b36ec0-9d77-4032-afba-4877a94ad931"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 5 is correct\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 6\n",
        "# Given the list of numbers defined below, reverse the list of numbers that you created above.\n",
        "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "\n",
        "numbers.sort(reverse=True)\n",
        "assert numbers == [10, 9, 8, 7, 6, 5, 4, 3, 2, 1], \"Assert Error means that the answer is incorrect.\"\n",
        "print(\"Exercise 6 is correct.\")"
      ],
      "metadata": {
        "id": "2x4qFPSgqmDh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eecad587-5250-45e2-fa16-f0c7a1d5ba86"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 6 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 7\n",
        "# Sort the vegetables in alphabetical order\n",
        "vegetables.sort()\n",
        "assert vegetables == ['broccoli', 'carrot', 'cauliflower', 'eggplant', 'zucchini']\n",
        "print(\"Exercise 7 is correct.\")"
      ],
      "metadata": {
        "id": "TlT-8Jmzqpb_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "65c68594-76d1-444f-e497-9cf1d286b95a"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 7 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 8\n",
        "# Write the code necessary to sort the fruits in reverse alphabetical order\n",
        "fruits.sort(reverse=True)\n",
        "assert fruits == ['tomato', 'strawberry', 'mango', 'kiwi', 'guava', 'banana']\n",
        "print(\"Exercise 8 is correct.\")"
      ],
      "metadata": {
        "id": "TZUKbNM1qulZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3088570a-0dcb-4128-ae7e-04dd4a217181"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 8 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 9\n",
        "# Write the code necessary to produce a single list that holds all fruits then all vegetables in the order as they were sorted above.\n",
        "fruits.extend(vegetables)\n",
        "fruits_and_veggies = fruits\n",
        "assert fruits_and_veggies == ['tomato', 'strawberry', 'mango', 'kiwi', 'guava', 'banana', 'broccoli', 'carrot', 'cauliflower', 'eggplant', 'zucchini']\n",
        "\n",
        "print(\"Exercise 9 is correct\")"
      ],
      "metadata": {
        "id": "MopnqOvpq451",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "03320d19-078b-4fbd-da04-0fa6475628be"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 9 is correct\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Functions\n",
        " Be sure to `return` values from your function definitions. The assert statements will call your function(s) for you.\n",
        "\n"
      ],
      "metadata": {
        "id": "oWLyvC9LrBCR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Run this cell in order to generate some numbers to use in our functions after this.\n",
        "import random\n",
        "\n",
        "positive_even_number = random.randrange(2, 101, 2)\n",
        "negative_even_number = random.randrange(-100, -1, 2)\n",
        "\n",
        "positive_odd_number = random.randrange(1, 100, 2)\n",
        "negative_odd_number = random.randrange(-101, 0, 2)\n",
        "print(\"We now have some random numbers available for future exercises.\")\n",
        "print(\"The random positive even number is\", positive_even_number)\n",
        "print(\"The random positive odd nubmer is\", positive_odd_number)\n",
        "print(\"The random negative even number\", negative_even_number)\n",
        "print(\"The random negative odd number\", negative_odd_number)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mA1EpbOcsIIO",
        "outputId": "89afdef9-f8ef-4f30-beaa-c4961424122d"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "We now have some random numbers available for future exercises.\n",
            "The random positive even number is 6\n",
            "The random positive odd nubmer is 63\n",
            "The random negative even number -78\n",
            "The random negative odd number -65\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example function defintion:\n",
        "# Write a say_hello function that adds the string \"Hello, \" to the beginning and \"!\" to the end of any given input.\n",
        "def say_hello(name):\n",
        "    return \"Hello, \" + name + \"!\"\n",
        "\n",
        "assert say_hello(\"Jane\") == \"Hello, Jane!\", \"Double check the inputs and data types\"\n",
        "assert say_hello(\"Pat\") == \"Hello, Pat!\", \"Double check the inputs and data types\"\n",
        "assert say_hello(\"Astrud\") == \"Hello, Astrud!\", \"Double check the inputs and data types\"\n",
        "print(\"The example function definition ran appropriately\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HcbHpZ4trI-W",
        "outputId": "d34780c4-da1e-4d96-ccc0-9e806d8d780d"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The example function definition ran appropriately\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Another example function definition:\n",
        "# This plus_two function takes in a variable and adds 2 to it.\n",
        "def plus_two(number):\n",
        "    return number + 2\n",
        "\n",
        "assert plus_two(3) == 5\n",
        "assert plus_two(0) == 2\n",
        "assert plus_two(-2) == 0\n",
        "print(\"The plus_two assertions executed appropriately... The second function definition example executed appropriately.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BiIErtZbrQI7",
        "outputId": "ccfbb4d1-038d-4dc5-8769-abf6585dcbf3"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The plus_two assertions executed appropriately... The second function definition example executed appropriately.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 10\n",
        "# Write a function definition for a function named add_one that takes in a number and returns that number plus one.\n",
        "def add_one(n):\n",
        " return n+1\n",
        "\n",
        "assert add_one(2) == 3, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
        "assert add_one(0) == 1, \"Zero plus one is one.\"\n",
        "assert add_one(positive_even_number) == positive_even_number + 1, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
        "assert add_one(negative_odd_number) == negative_odd_number + 1, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
        "print(\"Exercise 10 is correct.\")"
      ],
      "metadata": {
        "id": "EUGkV7nTrZbA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2a46cf41-2397-4f9f-9900-a59a8408d8a4"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 10 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 11\n",
        "# Write a function definition named is_odd that takes in a number and returns True or False if that number is odd.\n",
        "def is_odd(n):\n",
        "  if n%2==1:\n",
        "    return True\n",
        "  else:\n",
        "    return False\n",
        "assert is_odd(positive_odd_number) == True, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
        "assert is_odd(positive_even_number) == False, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
        "assert is_odd(negative_odd_number) == True, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
        "assert is_odd(negative_even_number) == False, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
        "print(\"Exercise 11 is correct.\")"
      ],
      "metadata": {
        "id": "iTQVLcarrcG3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b4c60f1b-8ef8-445d-e96d-988a65891012"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 11 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 12\n",
        "# Write a function definition named is_positive_even that takes in a number and returns True or False if the value is both greater than zero and even\n",
        "def is_positive_even(n):\n",
        "  if n>0 and n%2==0:\n",
        "    return True\n",
        "  else:\n",
        "    return False\n",
        "assert is_positive_even(4) == True, \"Double check your syntax and logic\"\n",
        "assert is_positive_even(positive_odd_number) == False, \"Double check your syntax and logic\"\n",
        "assert is_positive_even(positive_even_number) == True, \"Double check your syntax and logic\"\n",
        "assert is_positive_even(negative_odd_number) == False, \"Double check your syntax and logic\"\n",
        "assert is_positive_even(negative_even_number) == False, \"Double check your syntax and logic\"\n",
        "print(\"Exercise 12 is correct.\")"
      ],
      "metadata": {
        "id": "G6Ai1Dhrri5D",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7fd5a210-0051-4b94-b454-8a14fa03744c"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 12 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 13\n",
        "# Write a function definition named double that takes in a number and returns double the provided number.\n",
        "def double(n):\n",
        "  return 2*n\n",
        "assert double(4) == 8\n",
        "assert double(5) == 10\n",
        "assert double(positive_odd_number) == positive_odd_number * 2\n",
        "assert double(positive_even_number) == positive_even_number * 2\n",
        "assert double(negative_odd_number) == negative_odd_number * 2\n",
        "assert double(negative_even_number) == negative_even_number * 2\n",
        "print(\"Exercise 13 is correct.\")"
      ],
      "metadata": {
        "id": "tm5TrqFArsjH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f7cd7f94-cde1-4c1e-f8b5-a1121060c067"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 13 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 14\n",
        "# Write a function definition named sum_of_squares that takes in two numbers, squares each number, then returns the sum of both squares.\n",
        "def sum_of_squares(x,y):\n",
        "  return x**2+y**2\n",
        "assert sum_of_squares(3, 2) == 13\n",
        "assert sum_of_squares(5, 2) == 29\n",
        "assert sum_of_squares(2, 4) == 20\n",
        "print(\"Exercise 14 is correct.\")"
      ],
      "metadata": {
        "id": "GSrhmkNwr6Qn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "def1db12-d61f-4471-e473-7c683ee93cbd"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 14 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Functions with Strings\n",
        "I recommend you go through the two google colab files I have shared if you have difficulty in this."
      ],
      "metadata": {
        "id": "PaiPvt74srzZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 15\n",
        "# Write a function definition named has_vowels that takes in value and returns True if the string contains any vowels.\n",
        "def has_vowels(s):\n",
        " for  x in s:\n",
        "  if x in 'aeiouAEIOU':\n",
        "    return True\n",
        "    break\n",
        " return False\n",
        "\n",
        "assert has_vowels(\"banana\") == True\n",
        "assert has_vowels(\"ubuntu\") == True\n",
        "assert has_vowels(\"QQQQ\") == False\n",
        "assert has_vowels(\"wyrd\") == False\n",
        "print(\"Exercise 15 is correct.\")"
      ],
      "metadata": {
        "id": "4auRgTnMsbet",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6ab13456-8aae-4c42-ff38-0eef83471db0"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 15 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 16\n",
        "# Write a function definition named count_vowels that takes in value and returns the count of the nubmer of vowels in a sequence.\n",
        "def count_vowels(s):\n",
        "  count=0\n",
        "  for x in s:\n",
        "    if x in 'aeiouAEIOU':\n",
        "      count+=1\n",
        "  return count\n",
        "assert count_vowels(\"banana\") == 3\n",
        "assert count_vowels(\"ubuntu\") == 3\n",
        "assert count_vowels(\"mango\") == 2\n",
        "assert count_vowels(\"QQQQ\") == 0\n",
        "assert count_vowels(\"wyrd\") == 0\n",
        "print(\"Exercise 16 is correct.\")"
      ],
      "metadata": {
        "id": "QN-lkLYftB0q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "603be4bb-5914-4df6-cefa-09cf2a9e720b"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 16 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 17\n",
        "# Write a function definition named remove_vowels that takes in string and returns the string without any vowels\n",
        "def remove_vowels(s):\n",
        "  for x in s:\n",
        "    if x in 'aeiouAEIOU':\n",
        "      s=s.replace(x,'')\n",
        "  return s\n",
        "assert remove_vowels(\"banana\") == \"bnn\"\n",
        "assert remove_vowels(\"ubuntu\") == \"bnt\"\n",
        "assert remove_vowels(\"mango\") == \"mng\"\n",
        "assert remove_vowels(\"QQQQ\") == \"QQQQ\"\n",
        "print(\"Exercise 17 is correct.\")"
      ],
      "metadata": {
        "id": "3Uswu498tGDe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fa25d261-432f-478c-a796-9d33ad63e987"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 17 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 18\n",
        "# Write a function definition named starts_and_ends_with_vowel that takes in string and returns True if the string starts and ends with a vowel\n",
        "def starts_and_ends_with_vowel(s):\n",
        "  if s[0] in 'aeiouAEIOU' and s[-1] in 'aeiouAEIOU':\n",
        "    return True\n",
        "  else:\n",
        "    return False\n",
        "assert starts_and_ends_with_vowel(\"ubuntu\") == True\n",
        "assert starts_and_ends_with_vowel(\"banana\") == False\n",
        "assert starts_and_ends_with_vowel(\"mango\") == False\n",
        "print(\"Exercise 18 is correct.\")"
      ],
      "metadata": {
        "id": "WabXu0XxtLCR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "764ae384-a34c-4e68-814d-11a5250fa582"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 18 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Accessing List Elements\n"
      ],
      "metadata": {
        "id": "xCqaLNfCtcgG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 19\n",
        "# Write a function definition named first that takes in sequence and returns the first value of that sequence.\n",
        "def first(s):\n",
        "  return s[0]\n",
        "assert first(\"ubuntu\") == \"u\"\n",
        "assert first([1, 2, 3]) == 1\n",
        "assert first([\"python\", \"is\", \"awesome\"]) == \"python\"\n",
        "print(\"Exercise 19 is correct.\")"
      ],
      "metadata": {
        "id": "SA7pw41btcI-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19d618b2-3bdb-4bb8-9d1d-a617fe4b5d35"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 19 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 20\n",
        "# Write a function definition named last that takes in sequence and returns the last value of that sequence.\n",
        "def last(s):\n",
        "  return s[-1]\n",
        "assert last(\"ubuntu\") == \"u\"\n",
        "assert last([1, 2, 3, 4]) == 4\n",
        "assert last([\"python\", \"is\", \"awesome\"]) == \"awesome\"\n",
        "assert last([\"kiwi\", \"mango\", \"guava\"]) == \"guava\"\n",
        "print(\"Exercise 20 is correct.\")"
      ],
      "metadata": {
        "id": "2LUxN5jitowc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "48dd8f6f-6426-4714-cbc6-d44d574096a6"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 20 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 21\n",
        "# Write a function definition named first_and_second that takes in sequence and returns the first and second value of that sequence as a list\n",
        "def first_and_second(s):\n",
        "  return [s[0],s[1]]\n",
        "assert first_and_second([1, 2, 3, 4]) == [1, 2]\n",
        "assert first_and_second([\"python\", \"is\", \"awesome\"]) == [\"python\", \"is\"]\n",
        "assert first_and_second([\"strawberry\", \"kiwi\", \"mango\", \"guava\"]) == [\"strawberry\", \"kiwi\"]\n",
        "print(\"Exercise 21 is correct.\")"
      ],
      "metadata": {
        "id": "gdY9_AJCttvJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c447411b-3283-45fc-bb2a-6063946ada9e"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 21 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 22\n",
        "# Write a function definition named first_to_last that takes in sequence and returns the sequence with the first value moved to the end of the sequence.\n",
        "def first_to_last(s):\n",
        "  return s[1:]+[s[0]]\n",
        "assert first_to_last([1, 2, 3, 4]) == [2, 3, 4, 1]\n",
        "assert first_to_last([\"python\", \"is\", \"awesome\"]) == [\"is\", \"awesome\", \"python\"]\n",
        "assert first_to_last([\"strawberry\", \"kiwi\", \"mango\", \"guava\"]) == [\"kiwi\", \"mango\", \"guava\", \"strawberry\"]\n",
        "print(\"Exercise 22 is correct.\")"
      ],
      "metadata": {
        "id": "cDPGhuedt0OF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "78346106-8b45-4b44-b77a-3671e34a6f33"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 22 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Functions to Describe Data\n"
      ],
      "metadata": {
        "id": "8LRyayWlt6ZN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 23\n",
        "# Write a function definition named sum_all that takes in sequence of numbers and returns all the numbers added together.\n",
        "def sum_all(s):\n",
        "  sum=0\n",
        "  for x in s:\n",
        "    sum+=x\n",
        "  return sum\n",
        "assert sum_all([1, 2, 3, 4]) == 10\n",
        "assert sum_all([3, 3, 3]) == 9\n",
        "assert sum_all([0, 5, 6]) == 11\n",
        "print(\"Exercise 23 is correct.\")"
      ],
      "metadata": {
        "id": "m2sAHpw-t58l",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a63a4e4f-67f2-46e8-8680-9fc834baa773"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 23 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 24\n",
        "# Write a function definition named mean that takes in sequence of numbers and returns the average value\n",
        "def mean(s):\n",
        "  sum=0\n",
        "  for x in s:\n",
        "    sum+=x\n",
        "  return sum/len(s)\n",
        "assert mean([1, 2, 3, 4, 5]) == 3.0\n",
        "assert mean([1, 2, 3]) == 2.0\n",
        "assert mean([1, 5, 6]) == 4.0\n",
        "assert mean([1, 2, 5, 6]) == 3.5\n",
        "print(\"Exercise 24 is correct.\")"
      ],
      "metadata": {
        "id": "Mt2EeKsfuEIW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "82cf8f4c-5635-4b1c-f0a8-6be52a2ee94e"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 24 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 24\n",
        "# Write a function definition named mode that takes in sequence of numbers and returns the most commonly occuring value\n",
        "def mode(s):\n",
        "assert mode([1, 2, 2, 3, 4]) == 2\n",
        "assert mode([1, 1, 2, 3]) == 1\n",
        "assert mode([2, 2, 3, 3, 3]) == 3\n",
        "print(\"Exercise 24 is correct.\")"
      ],
      "metadata": {
        "id": "HgLdQbNTuMqz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Applying Functions to Lists\n"
      ],
      "metadata": {
        "id": "F_MVcTfIuSiy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 25\n",
        "# Write a function definition named get_highest_number that takes in sequence of numbers and returns the largest number.\n",
        "def get_highest_number(s):\n",
        "  return max(s)\n",
        "assert get_highest_number([1, 2, 3]) == 3\n",
        "assert get_highest_number([-5, -4, -3, -2, -1, 1, 2, 3, 4, 5]) == 5\n",
        "assert get_highest_number([-5, -3, 1]) == 1\n",
        "print(\"Exercise 25 is correct.\")"
      ],
      "metadata": {
        "id": "KAyrqevouXow",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a02454f9-ab26-428d-ddc6-3e1d4f73e4d5"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 25 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 26\n",
        "# Write a function definition named only_odd_numbers that takes in sequence of numbers and returns the odd numbers in a list.\n",
        "def only_odd_numbers(s):\n",
        "  return [x for x in s if x%2==1]\n",
        "assert only_odd_numbers([1, 2, 3]) == [1, 3]\n",
        "assert only_odd_numbers([-5, -4, -3, -2, -1, 1, 2, 3, 4, 5]) == [-5, -3, -1, 1, 3, 5]\n",
        "assert only_odd_numbers([-4, -3, 1]) == [-3, 1]\n",
        "assert only_odd_numbers([2, 2, 2, 2, 2]) == []\n",
        "print(\"Exercise 26 is correct.\")"
      ],
      "metadata": {
        "id": "517qI-KmucIa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1ddb1575-9c32-4fc1-8a88-36b52b7d68a3"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 26 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 27\n",
        "# Write a function definition named count_evens that takes in sequence of numbers and returns the number of even numbers\n",
        "def count_evens(s):\n",
        "  count=0\n",
        "  for x in s:\n",
        "    if x%2==0:\n",
        "      count+=1\n",
        "  return count\n",
        "assert count_evens([1, 2, 3]) == 1\n",
        "assert count_evens([2, 5, 6]) == 2\n",
        "assert count_evens([3, 3, 3]) == 0\n",
        "assert count_evens([5, 6, 7, 8] ) == 2\n",
        "print(\"Exercise 27 is correct.\")"
      ],
      "metadata": {
        "id": "uCpfD1NnugoD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6587fafa-d788-4cdc-c3b3-e9ddbd801b80"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 27 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 28\n",
        "# Write a function definition named shortest_string that takes in a list of strings and returns the shortest string in the list.\n",
        "def shortest_string(s):\n",
        "  return min(s,key=len)\n",
        "assert shortest_string([\"kiwi\", \"mango\", \"strawberry\"]) == \"kiwi\"\n",
        "assert shortest_string([\"hello\", \"everybody\"]) == \"hello\"\n",
        "assert shortest_string([\"mary\", \"had\", \"a\", \"little\", \"lamb\"]) == \"a\"\n",
        "print(\"Exercise 28 is correct.\")"
      ],
      "metadata": {
        "id": "RxqDOb7Wum-C",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2036175b-b1f2-4c5e-963a-5fb407aa29dd"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 28 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Working with Sets\n",
        "Take a look at the `set` function in Python, the `set` data type, and built-in `set` methods."
      ],
      "metadata": {
        "id": "D9arvRTSu482"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example set function usage\n",
        "print(set(\"kiwi\"))\n",
        "print(set([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4XjNxjkFu4b-",
        "outputId": "2126f541-9567-4d09-cb35-c3e3139d2922"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'w', 'k', 'i'}\n",
            "{1, 2, 3, 4}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 29\n",
        "# Write a function definition named get_unique_values that takes in a list and returns a set with only the unique values from that list.\n",
        "\n",
        "assert get_unique_values([\"ant\", \"ant\", \"mosquito\", \"mosquito\", \"ladybug\"]) == {\"ant\", \"mosquito\", \"ladybug\"}\n",
        "assert get_unique_values([\"b\", \"a\", \"n\", \"a\", \"n\", \"a\", \"s\"]) == {\"b\", \"a\", \"n\", \"s\"}\n",
        "assert get_unique_values([\"mary\", \"had\", \"a\", \"little\", \"lamb\", \"little\", \"lamb\", \"little\", \"lamb\"]) == {\"mary\", \"had\", \"a\", \"little\", \"lamb\"}\n",
        "print(\"Exercise 29 is correct.\")"
      ],
      "metadata": {
        "id": "D3N-ZOg6vTpM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 30\n",
        "# Write a function definition named get_values_in_common that takes two lists and returns a single set with the values that each list has in common\n",
        "\n",
        "assert get_values_in_common([5, 1, 2, 3], [3, 4, 5, 5]) == {3, 5}\n",
        "assert get_values_in_common([1, 2], [2, 2, 3]) == {2}\n",
        "assert get_values_in_common([\"tomato\", \"mango\", \"kiwi\"], [\"eggplant\", \"tomato\", \"broccoli\"]) == {\"tomato\"}\n",
        "print(\"Exercise 30 is correct.\")"
      ],
      "metadata": {
        "id": "myQNUXapvXee"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "pzrDil06vdDj"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}