Ineuron_Python_Advanced_Programming11.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming11.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ICZXpqF7OEMT"
      },
      "source": [
        "# Ineuron Python Advanced Programming 11"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4QtnHnhBOLtU"
      },
      "source": [
        ">Q. 1. Create a function that takes a list and returns a new list containing only\n",
        "prime numbers.\n",
        "Examples\n",
        "filter_primes([7, 9, 3, 9, 10, 11, 27]) ➞ [7, 3, 11]\n",
        "filter_primes([10007, 1009, 1007, 27, 147, 77, 1001, 70]) ➞ [10007, 1009]\n",
        "filter_primes([1009, 10, 10, 10, 3, 33, 9, 4, 1, 61, 63, 69, 1087, 1091, 1093,\n",
        "1097]) ➞ [1009, 3, 61, 1087, 1091, 1093, 1097]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MoDdXybCOCD5"
      },
      "source": [
        "def isPrime(num1): \n",
        "    if num1 > 1:\n",
        "        for i in range(2,num1):\n",
        "            if (num1%i) == 0:\n",
        "                #print(num1,'is not a prime')                \n",
        "                break\n",
        "        else:\n",
        "            return True\n",
        "    else:\n",
        "        return False\n",
        "    \n",
        "def filter_primes(lst):\n",
        "    new_lst = [i for i in lst if isPrime(i)]\n",
        "    return new_lst"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hqxqG9vROROd",
        "outputId": "edb454db-65af-4b89-fb71-fecf5c5e235a"
      },
      "source": [
        "filter_primes([7, 9, 3, 9, 10, 11, 27])\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[7, 3, 11]"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gI6niQOrOTPL",
        "outputId": "23af831e-9122-4f95-c17a-8c4433398d76"
      },
      "source": [
        "filter_primes([10007, 1009, 1007, 27, 147, 77, 1001, 70])\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10007, 1009]"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U6M7JWJFOVkW",
        "outputId": "ee1fef99-e1e2-45cc-90f5-44b407507758"
      },
      "source": [
        "filter_primes([1009, 10, 10, 10, 3, 33, 9, 4, 1, 61, 63, 69, 1087, 1091, 1093,1097])\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1009, 3, 61, 1087, 1091, 1093, 1097]"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zi6G9h2KOZdJ"
      },
      "source": [
        ">Q. 2. Once a water balloon pops, is soaks the area around it. The ground gets\n",
        "drier the further away you travel from the balloon.\n",
        "The effect of a water balloon popping can be modeled using a list. Create a\n",
        "function that takes a list which takes the pre-pop state and returns the state\n",
        "after the balloon is popped. The pre-pop state will contain at most a single\n",
        "balloon, whose size is represented by the only non-zero element.\n",
        "Examples\n",
        "pop([0, 0, 0, 0, 4, 0, 0, 0, 0]) ➞ [0, 1, 2, 3, 4, 3, 2, 1, 0]\n",
        "pop([0, 0, 0, 3, 0, 0, 0]) ➞ [0, 1, 2, 3, 2, 1, 0]\n",
        "pop([0, 0, 2, 0, 0]) ➞ [0, 1, 2, 1, 0]\n",
        "pop([0]) ➞ [0]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_O6xBV95OW6b"
      },
      "source": [
        "def pop(lst):\n",
        "    length = len(lst)//2\n",
        "    fw = bw = length\n",
        "    while(bw > 0):\n",
        "        lst[bw] = length \n",
        "        lst[fw] = length\n",
        "        bw -= 1\n",
        "        fw += 1\n",
        "        length -= 1\n",
        "    return lst"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8banjOZPOby8",
        "outputId": "e0fbc6a4-0162-4f4b-98e4-715a5c396618"
      },
      "source": [
        "pop([0, 0, 0, 0, 4, 0, 0, 0, 0])\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 2, 3, 4, 3, 2, 1, 0]"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eOCIfoXUOc64",
        "outputId": "a1aa29cb-1a96-4668-b3d5-0875ad186af3"
      },
      "source": [
        "pop([0, 0, 0, 3, 0, 0, 0])\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 2, 3, 2, 1, 0]"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lpujBwt-OeZz",
        "outputId": "d4bf4027-9a82-4e06-a6f8-ac231490161c"
      },
      "source": [
        "pop([0, 0, 2, 0, 0])\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 2, 1, 0]"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hJbCMz9EOgPW",
        "outputId": "42a51e38-fb94-48af-ae35-b383da6c2d28"
      },
      "source": [
        "pop([0])\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0]"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F6ZSGaAROleQ"
      },
      "source": [
        ">Q. 3. 'Loves me, loves me not' is a traditional game in which a person plucks off\n",
        "all the petals of a flower one by one, saying the phrase 'Loves me' and\n",
        "'Loves me not' when determining whether the one that they love, loves them\n",
        "back.\n",
        "Given a number of petals, return a string which repeats the phrases 'Loves\n",
        "me' and 'Loves me not' for every alternating petal, and return the last phrase\n",
        "in all caps. Remember to put a comma and space between phrases.\n",
        "Examples\n",
        "loves_me(3) ➞ 'Loves me, Loves me not, LOVES ME'\n",
        "loves_me(6) ➞ 'Loves me, Loves me not, Loves me, Loves me not, Loves\n",
        "me, LOVES ME NOT'\n",
        "\n",
        "loves_me(1) ➞ 'LOVES ME'"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-vUjjdOXOhc5"
      },
      "source": [
        "def loves_me(n):\n",
        "    lst =[]\n",
        "    for i in range(1,n+1):\n",
        "        if i % 2 == 0:\n",
        "            lst.append(\"Loves me not\")\n",
        "        else:\n",
        "            lst.append(\"Loves me\")\n",
        "\n",
        "    lst[-1] = lst[-1].upper()\n",
        "    return \", \".join(lst)"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "yepldwPKOnzU",
        "outputId": "0b534d2c-41a7-49d7-fcd3-793bbbfd8378"
      },
      "source": [
        "loves_me(3)\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Loves me, Loves me not, LOVES ME'"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "ZYVh1LwaOpoN",
        "outputId": "5b328b75-fa14-4a30-cbc9-533559f127c2"
      },
      "source": [
        "loves_me(6)\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Loves me, Loves me not, Loves me, Loves me not, Loves me, LOVES ME NOT'"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "FCb-GMkYOrku",
        "outputId": "203198fa-52af-4a87-b03d-9fc5e4f3851b"
      },
      "source": [
        "loves_me(1)\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'LOVES ME'"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vKBomUD7OvQ7"
      },
      "source": [
        ">Q. 4. Write a function that sorts each string in a list by the letter in alphabetic\n",
        "ascending order (a-z).\n",
        "Examples\n",
        "sort_by_letter(['932c', '832u32', '2344b'])\n",
        "➞ ['2344b', '932c', '832u32']\n",
        "sort_by_letter(['99a', '78b', 'c2345', '11d'])\n",
        "➞ ['99a', '78b', 'c2345', '11d']\n",
        "sort_by_letter(['572z', '5y5', '304q2'])\n",
        "➞ ['304q2', '5y5', '572z']\n",
        "sort_by_letter([])\n",
        "➞ []"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hCwSH4PwOs8J"
      },
      "source": [
        "\n",
        "def f_l(w):\n",
        "    for j in w:\n",
        "        if j.isalpha():\n",
        "            x=j\n",
        "            # print(x)\n",
        "    return x\n",
        "\n",
        "\n",
        "def sort_by_letter(l):\n",
        "    if len(l)>0:\n",
        "        m = l[0]\n",
        "        for i in range(len(l)-1):\n",
        "            for j in range(i+1,len(l)):\n",
        "                if ord(f_l(l[i])) > ord(f_l(l[j])):\n",
        "                    temp = l[i]\n",
        "                    l[i]=l[j]\n",
        "                    l[j]=temp\n",
        "    return l"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cXY9M36dOznA",
        "outputId": "0bb86edc-8c38-4380-d289-0cb716948111"
      },
      "source": [
        "sort_by_letter(['932c', '832u32', '2344b'])\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['2344b', '932c', '832u32']"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y6e6ZA02O1hy",
        "outputId": "26c85837-9b0c-4fb3-aa13-97e0ed81394a"
      },
      "source": [
        "sort_by_letter(['99a', '78b', 'c2345', '11d'])\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['99a', '78b', 'c2345', '11d']"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w--CoIguO3OQ",
        "outputId": "d00b2356-35a4-4826-b5c1-dc0ebdd0a290"
      },
      "source": [
        "sort_by_letter(['572z', '5y5', '304q2'])\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['304q2', '5y5', '572z']"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yq4_nC9BO6Pa",
        "outputId": "8228f4ba-73a3-4de5-a96e-3af9829f7261"
      },
      "source": [
        "sort_by_letter([])\n"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i20FG9NTO9wv"
      },
      "source": [
        ">Q.5. There are three cups on a table, at positions A, B, and C. At the start, there\n",
        "is a ball hidden under the cup at position B.\n",
        "\n",
        "However, I perform several swaps on the cups, which is notated as two\n",
        "letters. For example, if I swap the cups at positions A and B, I could notate\n",
        "this as AB or BA.\n",
        "Create a function that returns the letter position that the ball is at, once I finish\n",
        "swapping the cups. The swaps will be given to you as a list.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sU6pqpv7O7h6",
        "outputId": "9b2ed9f2-80dd-4944-ff21-7d6f469d3ab5"
      },
      "source": [
        "\n",
        "def cup_swapping(l):\n",
        "    for i in l:\n",
        "        if \"B\" in i:\n",
        "            ball= i.replace('B', '')\n",
        "            y=+1\n",
        "            break\n",
        "    for j in range(y,len(l)):\n",
        "        if ball in l[j]:\n",
        "            ball = l[j].replace(ball,'')\n",
        "    return ball\n",
        "\n",
        "print(cup_swapping(['CA','AB', 'CA', 'CB','AB']))"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "C\n"
          ]
        }
      ]
    }
  ]
}