Ineuron_Python_Advanced_Programming18.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming18.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_SIXjwUz02bR"
      },
      "source": [
        "#Ineuron Python Advanced Programming 18"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZJDpDH_r29dp"
      },
      "source": [
        ">Q. A robot has been given a list of movement instructions. Each instruction is either left, right, up or down, followed by a distance to move. The robot starts at [0, 0]. You want to calculate where the robot will end up and return its final position as a list.\n",
        "\n",
        "To illustrate, if the robot is given the following instructions:\n",
        "\n",
        "[\"right 10\", \"up 50\", \"left 30\", \"down 10\"]\n",
        "\n",
        "It will end up 20 left and 40 up from where it started, so we return [-20, 40].\n",
        "\n",
        "Examples\n",
        "\n",
        "track_robot([\"right 10\", \"up 50\", \"left 30\", \"down 10\"]) ➞ [-20, 40]\n",
        "\n",
        "track_robot([]) ➞ [0, 0] // If there are no instructions, the robot doesn't move.\n",
        "\n",
        "track_robot([\"right 100\", \"right 100\", \"up 500\", \"up 10000\"]) ➞ [200, 10500]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SfAuKtFE0w0b"
      },
      "source": [
        "def track_robot(lst):\n",
        "    start=[0,0]\n",
        "    for i in lst:\n",
        "        way,val=i.split(\" \")\n",
        "        if way ==\"right\":\n",
        "            start[0] +=int(val)\n",
        "        elif way ==\"left\":\n",
        "            start[0] -=int(val)\n",
        "        elif way ==\"up\":\n",
        "            start[1] +=int(val)\n",
        "        else:\n",
        "            start[1] -=int(val)\n",
        "    return (start)"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "10kWtvBu3D3O",
        "outputId": "13d367cf-3337-4534-b473-4bdba83a5b79"
      },
      "source": [
        "track_robot([])\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 0]"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UvUKEJJB3E_g",
        "outputId": "a3de1998-3849-4d71-c952-67e2a7a74328"
      },
      "source": [
        "track_robot([\"right 100\", \"right 100\", \"up 500\", \"up 10000\"])\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[200, 10500]"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NQltI7e63GGm",
        "outputId": "166b7c74-8a13-45ed-94ce-6f53d65e5998"
      },
      "source": [
        "track_robot([\"right 10\", \"up 50\", \"left 30\", \"down 10\"])\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[-20, 40]"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TkhUXtlr3KUU"
      },
      "source": [
        ">Q.2. Write a function that will return the longest word in a sentence. In cases where more than one word is found, return the first one.\n",
        "\n",
        "Examples\n",
        "\n",
        "find_longest(\"A thing of beauty is a joy forever.\") ➞ \"forever\"\n",
        "\n",
        "find_longest(\"Forgetfulness is by all means powerless!\") ➞ \"forgetfulness\"\n",
        "\n",
        "find_longest(\"\\\"Strengths\\\" is the longest and most commonly used word that contains only a single vowel.\") ➞ \"strengths\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rUmSg-4Z3HER"
      },
      "source": [
        "def find_longest(string):\n",
        "    new=string.split()\n",
        "    largest=\"\"\n",
        "    for i in new:\n",
        "        temp=\"\"\n",
        "        for j in i:\n",
        "            if j.isalpha():\n",
        "                temp+=j\n",
        "        if len(temp)> len(largest):\n",
        "            largest = temp\n",
        "\n",
        "    return (largest)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "ax-xb6lR3OJW",
        "outputId": "f557f523-1dcc-4568-c3d5-6e8fd63eef06"
      },
      "source": [
        "find_longest(\"A thing of beauty is a joy forever.\")\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'forever'"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "t0mA_Z5o3QZJ",
        "outputId": "1f303d3a-6e0d-48e7-fd8d-41b09184ed5d"
      },
      "source": [
        "find_longest(\"Forgetfulness is by all means powerless!\")\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Forgetfulness'"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "-rFvIoDJ3RgM",
        "outputId": "94542b29-6bac-401f-8005-421558a02954"
      },
      "source": [
        "find_longest(\"\\\"Strengths\\\" is the longest and most commonly used word that contains only a single vowel.\")\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Strengths'"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Kb7sTtv3WRn"
      },
      "source": [
        ">Q. 3. Create a function to check if a candidate is qualified in an imaginary coding interview of an imaginary tech startup.\n",
        "\n",
        "The criteria for a candidate to be qualified in the coding interview is:\n",
        "\n",
        "   1. The candidate should have complete all the questions.\n",
        "   2. The maximum time given to complete the interview is 120 minutes.\n",
        "   3. The maximum time given for very easy questions is 5 minutes each.\n",
        "   4. The maximum time given for easy questions is 10 minutes each.\n",
        "   5. The maximum time given for medium questions is 15 minutes each.\n",
        "   6. The maximum time given for hard questions is 20 minutes each.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jsnEOKS33Spi"
      },
      "source": [
        "def interview(lst,taken_time):\n",
        "    std =[5,5,10,10,15,15,20,20]\n",
        "    total_time=120\n",
        "    if len(lst)<len(std):\n",
        "        return \"disqualified\"\n",
        "    if taken_time>total_time:\n",
        "        return \"disqualified\"\n",
        "    for i in range(len(lst)):\n",
        "        if lst[i]>std[i]:\n",
        "            return \"disqualified\"\n",
        "    return \"qualified\""
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "ulJEtX8r3ZbJ",
        "outputId": "d1f4b444-ca83-4856-ae19-e3a71f228589"
      },
      "source": [
        "interview([5, 5, 10, 10, 15, 15, 20, 20], 120)\n"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'qualified'"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "kKeESmjA3asL",
        "outputId": "0c4a4ef1-2c24-42cb-8b17-01c197c0b444"
      },
      "source": [
        "interview([2, 3, 8, 6, 5, 12, 10, 18], 64)\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'qualified'"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "UHk6voO73cAA",
        "outputId": "4a416361-aa21-43bb-856b-0e4d07157b17"
      },
      "source": [
        "interview([5, 5, 10, 10, 25, 15, 20, 20], 120)\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'disqualified'"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "SAuFEsQX3d4I",
        "outputId": "0eee80ef-baa0-4626-b1bd-7e97238679e7"
      },
      "source": [
        "interview([5, 5, 10, 10, 15, 15, 20], 120)\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'disqualified'"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "0Ic-bDej3fZO",
        "outputId": "fd09d953-8642-4055-c0a9-6106e4792a12"
      },
      "source": [
        "interview([5, 5, 10, 10, 15, 15, 20, 20], 130)\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'disqualified'"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "bGZBfHGT3gvU",
        "outputId": "7988b005-204a-4020-b134-77e5013146e3"
      },
      "source": [
        "interview([5, 5, 10, 10, 25, 15, 20, 20], 120)\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'disqualified'"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LwyvEIkk3oxL"
      },
      "source": [
        ">Q.4. Write a function that divides a list into chunks of size n, where n is the length of each chunk.\n",
        "\n",
        "Examples\n",
        "\n",
        "chunkify([2, 3, 4, 5], 2) ➞ [[2, 3], [4, 5]]\n",
        "\n",
        "chunkify([2, 3, 4, 5, 6], 2) ➞ [[2, 3], [4, 5], [6]]\n",
        "\n",
        "chunkify([2, 3, 4, 5, 6, 7], 3) ➞ [[2, 3, 4], [5, 6, 7]]\n",
        "\n",
        "chunkify([2, 3, 4, 5, 6, 7], 1) ➞ [[2], [3], [4], [5], [6], [7]]\n",
        "\n",
        "chunkify([2, 3, 4, 5, 6, 7], 7) ➞ [[2, 3, 4, 5, 6, 7]]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oRVNFtLC3j6p"
      },
      "source": [
        "def chunkify(lst,num):\n",
        "    new=[lst[i:i + num] for i in range(0, len(lst), num)] \n",
        "    return new"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n-qA9se53qs-",
        "outputId": "ba28e287-9c41-467c-dd21-7669537b5979"
      },
      "source": [
        "chunkify([2, 3, 4, 5], 2)\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[2, 3], [4, 5]]"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OIH2Jxka34M0",
        "outputId": "f9785df6-ac01-41af-a0e9-d525c7a50e9e"
      },
      "source": [
        "chunkify([2, 3, 4, 5, 6], 2)\n"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[2, 3], [4, 5], [6]]"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P4YXKI9y35pi",
        "outputId": "1f0e7440-26e4-4edd-91d0-c691746734b9"
      },
      "source": [
        "chunkify([2, 3, 4, 5, 6, 7], 1)\n"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[2], [3], [4], [5], [6], [7]]"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4U7bNggB37M5",
        "outputId": "86cdc4d5-86d8-4a05-a4b3-839c260785cb"
      },
      "source": [
        "chunkify([2, 3, 4, 5, 6, 7], 7)\n"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[2, 3, 4, 5, 6, 7]]"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LBQ0b-b33-R8"
      },
      "source": [
        ">Q.5. You are given a list of strings consisting of grocery items, with prices in parentheses. Return a list of prices in float format.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "89Tre_Wg38Na"
      },
      "source": [
        "def get_prices(lst):\n",
        "  \n",
        "        \n",
        "     return [float(i.split(\"$\")[-1][:-1]) for i in lst]"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nQntEPQL4DuC",
        "outputId": "5b04a336-0632-4685-f25d-d2cde7b5b1b3"
      },
      "source": [
        "\n",
        "get_prices([\"salad ($4.99)\"])\n"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[4.99]"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W5nZyA3x4Ezj",
        "outputId": "37a18f57-cd91-401a-e01f-604ec5b55d64"
      },
      "source": [
        "get_prices([\n",
        "  \"artichokes ($1.99)\",\n",
        "  \"rotiserrie chicken ($5.99)\",\n",
        "  \"gum ($0.75)\"\n",
        "])"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1.99, 5.99, 0.75]"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NXswLEuQ4GSv",
        "outputId": "f6b8de27-2f2b-4893-947d-c3fcacc3e859"
      },
      "source": [
        "get_prices([\n",
        "  \"ice cream ($5.99)\",\n",
        "  \"banana ($0.20)\",\n",
        "  \"sandwich ($8.50)\",\n",
        "  \"soup ($1.99)\"\n",
        "])"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5.99, 0.2, 8.5, 1.99]"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    }
  ]
}