Kaggle_Exercises_in_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Kaggle_Exercises_in_Python.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPwAyoqPxCTgBP/9cHIDeCO",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/divyansh1195/Kaggle-ML-Exercise-Notebooks/blob/master/Kaggle_Exercises_in_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "22P6AI5d5gAH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "66b1b3e7-1775-4787-9429-6774309fecef"
      },
      "source": [
        "#Q1.\n",
        "def sign(n):\n",
        "  if n>0:\n",
        "    return +1\n",
        "  elif n<0:\n",
        "    return -1\n",
        "  else:\n",
        "    return 0\n",
        "sign(-7)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FbZfer2h6cx5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "b5937556-3be8-44bc-ca87-c5d27dd1aab9"
      },
      "source": [
        "help(round)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on built-in function round in module builtins:\n",
            "\n",
            "round(...)\n",
            "    round(number[, ndigits]) -> number\n",
            "    \n",
            "    Round a number to a given precision in decimal digits (default 0 digits).\n",
            "    This returns an int when called with one argument, otherwise the\n",
            "    same type as the number. ndigits may be negative.\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "agzOionz6RP0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a7fa14e0-57f4-491e-be12-f8afad752253"
      },
      "source": [
        "#Q2.\n",
        "def round_to_two_places(num):\n",
        "    \"\"\"Return the given number rounded to two decimal places. \n",
        "    \n",
        "    >>> round_to_two_places(3.14159)\n",
        "    3.14\n",
        "    \"\"\"\n",
        "    return round(num, ndigits=2)\n",
        "round_to_two_places(8888.489526252728)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8888.49"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8bwi0W8m7Edy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "27bd6ffd-e57e-44db-979f-40fcc9e08a98"
      },
      "source": [
        "#Q3.\n",
        "#when in previous question, ndigits=-3\n",
        "#ndigits=-1 rounds to the nearest 10, ndigits=-2 rounds to the nearest 100 and so on\n",
        "def round_to_two_places(num):\n",
        "    \"\"\"Return the given number rounded to two decimal places. \n",
        "    \n",
        "    >>> round_to_two_places(3.14159)\n",
        "    3.14\n",
        "    \"\"\"\n",
        "    return round(num, ndigits=-3)\n",
        "round_to_two_places(8888.489526252728)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9000.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o3Oijqj07z6Q",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "54d8f670-f358-47bd-9fc3-eedbbae556dd"
      },
      "source": [
        "#Q4.\n",
        "#swapping 2 variables a and b\n",
        "a=[1,2,3]\n",
        "b=[4,6,9]\n",
        "print(a)\n",
        "print(b)\n",
        "#create a temporary variable and assign values to it \n",
        "temp=a\n",
        "a=b\n",
        "b=temp\n",
        "print(a)\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3]\n",
            "[4, 6, 9]\n",
            "[4, 6, 9]\n",
            "[1, 2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OhCvXlA39rXQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Operator\tName\tDescription:\n",
        "#a + b\tAddition\tSum of a and b\n",
        "#a - b\tSubtraction\tDifference of a and b\n",
        "#a * b\tMultiplication\tProduct of a and b\n",
        "#a / b\tTrue division\tQuotient of a and b\n",
        "#a // b\tFloor division\tQuotient of a and b, removing fractional parts\n",
        "#a % b\tModulus\tInteger remainder after division of a by b\n",
        "#a ** b\tExponentiation\ta raised to the power of b\n",
        "#-a\tNegation\tThe negative of a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JCi_gDf4-DfJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "c285257f-f51d-49f0-ecf1-44d8be4c2cac"
      },
      "source": [
        "#Q5.\n",
        "# Variables representing the number of candies collected by alice, bob, and carol\n",
        "alice_candies = 121\n",
        "bob_candies = 77\n",
        "carol_candies = 109\n",
        "total_candies=alice_candies+bob_candies+carol_candies\n",
        "print(total_candies)\n",
        "to_smash=total_candies%3\n",
        "print(to_smash)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "307\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ddgqkt6H-_Pj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "e04c48a7-120b-4ad5-c39a-a3e35662ce73"
      },
      "source": [
        "#Q5.1\n",
        "def to_smash(total_candies, n_friends):\n",
        "    \"\"\"Return the number of leftover candies that must be smashed after distributing\n",
        "    the given number of candies evenly between 3 friends.\n",
        "    \n",
        "    >>> to_smash(91)\n",
        "    1\n",
        "    \"\"\"\n",
        "    total_candies=alice_candies+bob_candies+carol_candies\n",
        "    to_smash=total_candies % n_friends\n",
        "    if to_smash == 1:\n",
        "      print(\"Smashing 1 candy\")\n",
        "    else:\n",
        "      print(\"Smashing\", to_smash, \"candies\")\n",
        "    return to_smash\n",
        "alice_candies = 121\n",
        "bob_candies = 77\n",
        "carol_candies = 110\n",
        "n_friends=3\n",
        "to_smash(total_candies, n_friends)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Smashing 2 candies\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4sXrLU7FElRG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f0b84158-dc0e-4cbf-ea2d-e7cea09b9efe"
      },
      "source": [
        "#Q6.\n",
        "def number_is_negative(num):\n",
        "    return print(True if num<0 else False)\n",
        "number_is_negative(num=-7)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WCzjpJeVvtMZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "b7cac041-47a5-40c4-8f87-187e60a2592f"
      },
      "source": [
        "#Q7.\n",
        "#This condition would be pretty complicated to express using just and, or and not, but using boolean-to-integer conversion gives us this short solution.\n",
        "#return (int(ketchup) + int(mustard) + int(onion)) == 1\n",
        "def exactly_one_topping(ketchup, mustard, onion):\n",
        "    \"\"\"Return whether the customer wants exactly one of the three available toppings\n",
        "    on their hot dog.\n",
        "    \"\"\"\n",
        "    return (ketchup+mustard+onion)==1\n",
        "print(\"does the customer want exactly one topping?\", exactly_one_topping(1,0,0))\n",
        "print(\"does the customer want exactly one topping?\", exactly_one_topping(1,1,0))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "does the customer want exactly one topping? True\n",
            "does the customer want exactly one topping? False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "753XOXSjxXDt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "04164182-0169-4847-ea74-797b0c6237a9"
      },
      "source": [
        "#Q8.\n",
        "# \"\"\"Return the second element of the given list. If the list has no second element, return None.\"\"\"\n",
        "def select_second(L):\n",
        "  if len(L)>2:\n",
        "    return L[1]\n",
        "  return None\n",
        "L=[1,2,3,4,5]\n",
        "select_second(L)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6IFfbio9x5Dt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "520d62ab-109f-4879-f835-a1b8eaa79e5d"
      },
      "source": [
        "#Q9.\n",
        "#\"\"\"Given a list of teams, where each team is a list of names, return the 2nd player (captain from the last listed team.\"\"\"\n",
        "def losing_team_captain(teams):\n",
        "  #select last team with \"teams[-1]\" and now select captain of losing team with \"teams[-1][1]\".\n",
        "  return teams[-1][1]\n",
        "teams=[[1,2,3,4,5,6,7,8,9,10,11],[12,13,14,15,16,171,18,19,20,21,22]]\n",
        "losing_team_captain(teams)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "13"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "183-vptB04bV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "cef25a52-e2ab-4d87-bb96-eff242dbf3b6"
      },
      "source": [
        "#Q10.\n",
        "def purple_shell(racers):\n",
        "    \"\"\"Given a list of racers, set the first place racer (at the front of the list) to last\n",
        "    place and vice versa.\n",
        "    \n",
        "    >>> r = [\"Mario\", \"Bowser\", \"Luigi\"]\n",
        "    >>> purple_shell(r)\n",
        "    >>> r\n",
        "    [\"Luigi\", \"Bowser\", \"Mario\"]\n",
        "    \"\"\"\n",
        "    temp=racers[0]\n",
        "    racers[0]=racers[-1]\n",
        "    racers[-1]=temp\n",
        "    return racers\n",
        "racers=[\"Mario\", \"Bowser\", \"Luigi\"]\n",
        "purple_shell(racers)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Luigi', 'Bowser', 'Mario']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WoZUqSOBW66_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "deae707f-7f58-4254-9c5b-e3243a6123cf"
      },
      "source": [
        "#Q11.\n",
        "#A guest is considered 'fashionably late' if they arrived after at least half of the party's guests. \n",
        "#However, they must not be the very last guest (that's taking it too far). \n",
        "#In the above example, Mona and Gilbert are the only guests who were fashionably late.\n",
        "\n",
        "def fashionably_late(arrivals, name):\n",
        "    \"\"\"Given an ordered list of arrivals to the party and a name, return whether the guest with that\n",
        "    name was fashionably late.\n",
        "    \"\"\"\n",
        "    arrivals_len = len(arrivals)\n",
        "    mid_arrivals = arrivals_len / 2\n",
        "    guest_index = arrivals.index(name)#index defined based on name\n",
        "    return guest_index >= mid_arrivals and guest_index != (arrivals_len - 1) #\"!=\" means \"NOT EQUAL\" \n",
        "arrivals=['Adela', 'Fleda', 'Owen', 'May', 'Mona', 'Gilbert', 'Ford']\n",
        "print(\"Is Mona fashionably late?\", fashionably_late(arrivals, name='Mona'))\n",
        "print(\"Is Adela fashionably late?\", fashionably_late(arrivals, name='Adela'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Is Mona fashionably late? True\n",
            "Is Adela fashionably late? False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OcLM1T33hjMT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c6327d01-f911-42ca-fc87-519ce4ae061d"
      },
      "source": [
        "#Q12.\n",
        "#The for loop specifies-\n",
        "#1. the variable name to use (in this case, num)\n",
        "#2. the set of values to loop over (in this case, nums)\n",
        "#3. You use the word \"in\" to link them together.\n",
        "\n",
        "def has_lucky_number(nums):\n",
        "    \"\"\"Return whether the given list of numbers is lucky. A lucky list contains\n",
        "    at least one number divisible by 7.\n",
        "    \"\"\"\n",
        "    for num in nums:\n",
        "      if num % 7 == 0:\n",
        "        return True\n",
        "    ## We've exhausted the list without finding a lucky number\n",
        "    return False\n",
        "nums=[17,114,211,36,59]\n",
        "has_lucky_number(nums)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vi6z2F0nlkO0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "92565ee6-5169-4997-ac78-f844ecad171f"
      },
      "source": [
        "#Q13.1.\n",
        "import numpy as np\n",
        "X=np.array([1, 2, 3, 4])\n",
        "print(\"Values bigger than 2 are\", X[X>2])\n",
        "\n",
        "#append function-The append() method in python adds a single item to the existing list. \n",
        "#It doesn't return a new list of items but will modify the original list by adding the item to the end of the list. \n",
        "#example:\n",
        "#fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "#fruits.append(\"orange\")\n",
        "#print(fruits)\n",
        "#['apple', 'banana', 'cherry', 'orange']\n",
        "\n",
        "#Q13.2 by defining the function\n",
        "def numbers_greater_than_two(L, thres):\n",
        "    \"\"\"Return only those numbers from the list which are graeter than 2.\n",
        "    \"\"\"\n",
        "    #create an empty list \n",
        "    L_thres=[]\n",
        "    for ele in L: #ele stands for element\n",
        "      L_thres.append(ele>thres)\n",
        "    return L_thres\n",
        "L=[1,2,3,4]\n",
        "print(L)\n",
        "thres=2\n",
        "numbers_greater_than_two(L, thres)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Values bigger than 2 are [3 4]\n",
            "[1, 2, 3, 4]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[False, False, True, True]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pUCwjkywrCeG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4f2ab73b-739a-4ec0-e293-f544b469b145"
      },
      "source": [
        "#Q14.\n",
        "def menu_is_boring(meals):\n",
        "    \"\"\"Given a list of meals served over some period of time, return True if the\n",
        "    same meal has ever been served two days in a row, and False otherwise.\n",
        "    \"\"\"\n",
        "    for i in range(0,len(meals)-1):\n",
        "      if meals[i]==meals[i+1]:\n",
        "        return True\n",
        "    #we have exhausted the meals list without finding meals served 2 days in a row \n",
        "    return False\n",
        "meals=[\"duck\",\"chicken\",\"pork\",\"fish\", \"fish\"]\n",
        "#meals=['Spam', 'Eggs', 'Spam', 'Spam', 'Bacon', 'Spam']\n",
        "menu_is_boring(meals)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xe6hOFaOhJob",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Q15.\n",
        "#\"play_slot_machine()\". The number it returns is your winnings in dollars. Usually it returns 0. But sometimes you'll get lucky and get a big payday. \n",
        "#On average, how much money can you expect to gain (or lose) every time you play the machine? \n",
        "#estimate the average value of each pull using a technique called the Monte Carlo method. To estimate the average outcome, we simulate the scenario many times, and return the average result.\n",
        "#play_sloth_machine is predefined function which is not present here\n",
        "\n",
        "#refer Kaggle Kernel fr this"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wTbhR3-J23eL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        },
        "outputId": "db402f89-2591-422a-ec8e-419076a2476a"
      },
      "source": [
        "help(str.isdigit)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on method_descriptor:\n",
            "\n",
            "isdigit(...)\n",
            "    S.isdigit() -> bool\n",
            "    \n",
            "    Return True if all characters in S are digits\n",
            "    and there is at least one character in S, False otherwise.\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oF8rgreXwIiW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "96995e5c-07d3-4de3-cd29-6706340b04c7"
      },
      "source": [
        "#Q16.\n",
        "# a valid zip code is any string consisting of exactly 6 digits\n",
        "def is_valid_zip(zip_code):\n",
        "    \"\"\"Returns whether the input string is a valid (5 digit) zip code\n",
        "    \"\"\"\n",
        "    return len(zip_code)==6 and zip_code.isdigit()\n",
        "zip_code=str(342011)\n",
        "is_valid_zip(zip_code)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hvZP1Icp3ZcB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d2ac19a7-b790-4712-de68-2e098366c2f8"
      },
      "source": [
        "#Q17.\n",
        "def word_search(doc_list, keyword):\n",
        "    \"\"\"\n",
        "    Takes a list of documents (each document is a string) and a keyword. \n",
        "    Returns list of the index values into the original list for all documents \n",
        "    containing the keyword.\n",
        "\n",
        "    Example:\n",
        "    doc_list = [\"The Learn Python Challenge Casino.\", \"They bought a car\", \"Casinoville\"]\n",
        "    >>> word_search(doc_list, 'casino')\n",
        "    >>> [0]\n",
        "    \"\"\"\n",
        "    lists = [] \n",
        "    # Iterate through the indices (i) and elements (doc) of documents\n",
        "    for i, doc in enumerate(doc_list):\n",
        "        # Split the string doc into a list of words (according to whitespace)\n",
        "        tokens = doc.split()\n",
        "        # Make a transformed list where we 'normalize' each word to facilitate matching.\n",
        "        # Periods and commas are removed from the end of each word, and it's set to all lowercase.\n",
        "        normalized = [token.rstrip('.,').lower() for token in tokens]\n",
        "        # Is there a match? If so, update the list of matching indices.\n",
        "        if keyword.lower() in normalized:\n",
        "            indices.append(i)\n",
        "    return indices\n",
        "doc_list = [\"The Learn Python Challenge Casino.\", \"They bought a casino\", \"Casinoville\"]\n",
        "word_search(doc_list, 'casino')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    }
  ]
}