Ineuron_Python_Advanced_Programming13.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming13.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yKuY-OKdQXiF"
      },
      "source": [
        "# Ineuron Python Advanced Programming 13"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AZ4QRmo9QbMu"
      },
      "source": [
        ">Q.1. Create a function that takes a list and string. The function should remove the letters in the string from the list, and return the list.\n",
        "\n",
        "Examples\n",
        "\n",
        "remove_letters([\"s\", \"t\", \"r\", \"i\", \"n\", \"g\", \"w\"], \"string\") ➞ [\"w\"]\n",
        "\n",
        "remove_letters([\"b\", \"b\", \"l\", \"l\", \"g\", \"n\", \"o\", \"a\", \"w\"], \"balloon\") ➞ [\"b\", \"g\", \"w\"]\n",
        "\n",
        "remove_letters([\"d\", \"b\", \"t\", \"e\", \"a\", \"i\"], \"edabit\") ➞ []"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zG8sNtPsQQPZ"
      },
      "source": [
        "def remove_letters (l,w):\n",
        "    n=[]\n",
        "    for i in w:\n",
        "        n.append(i)\n",
        "    for item in n:\n",
        "        if item in l:\n",
        "            l.remove(item)\n",
        "    return l"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ghEJOMILQeBe",
        "outputId": "bb3343bc-92a0-4a3f-ce36-5942f8c361f2"
      },
      "source": [
        "remove_letters([\"d\", \"b\", \"t\", \"e\", \"a\", \"i\"], \"edabit\")\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XGYs_NJPQfSa",
        "outputId": "ba27bc53-ad03-4b83-e55a-1c6bb639cb2c"
      },
      "source": [
        "remove_letters([\"s\", \"t\", \"r\", \"i\", \"n\", \"g\", \"w\"], \"string\")\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['w']"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G-JYpkLhQgZG",
        "outputId": "67a1845f-934a-4717-c17a-9871d55126f1"
      },
      "source": [
        "remove_letters([\"b\", \"b\", \"l\", \"l\", \"g\", \"n\", \"o\", \"a\", \"w\"], \"balloon\")\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['b', 'g', 'w']"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nQji7vztQkEC"
      },
      "source": [
        ">Q. 2. A block sequence in three dimensions. We can write a formula for this one: Create a function that takes a number (step) as an argument and returns the amount of blocks in that step.\n",
        "Examples\n",
        "\n",
        "blocks(1) ➞ 5\n",
        "\n",
        "blocks(5) ➞ 39\n",
        "\n",
        "blocks(2) ➞ 12"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kL4LKDTWQhde"
      },
      "source": [
        "def blocks(l):\n",
        "    a=5\n",
        "    b=7\n",
        "    if(l==1):\n",
        "        return a\n",
        "    else:\n",
        "        for i in range (1,l):\n",
        "            a=a+b\n",
        "            b=b+1\n",
        "        return a"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c8JgjZG5Qm6U",
        "outputId": "0c6f8c09-1601-47c8-9a6b-9c335d0133b8"
      },
      "source": [
        "blocks(5)\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "39"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HIzmMn9cQoIJ",
        "outputId": "8734a775-7c94-48f2-8dfe-e60a054cc447"
      },
      "source": [
        "\n",
        "blocks(1)\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TWwK4rSsQplZ",
        "outputId": "1b7eb4c7-1a23-4f33-90a2-250b9fe9cdca"
      },
      "source": [
        "blocks(2)\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dUHd3v7OQsx-"
      },
      "source": [
        ">Q.3. Create a function that subtracts one positive integer from another, without using any arithmetic operators such as -, %, /, +, etc.\n",
        "\n",
        "Examples\n",
        "\n",
        "my_sub(5, 9) ➞ 4\n",
        "\n",
        "my_sub(10, 30) ➞ 20\n",
        "\n",
        "my_sub(0, 0) ➞ 0"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ivbDGil7Qqyp"
      },
      "source": [
        "def my_sub(a,b):\n",
        "    n=[1 for i in range(a)]\n",
        "    m=[1 for i in range(b)]\n",
        "    for item in n:\n",
        "        if item in m:\n",
        "            m.remove(item)\n",
        "    return sum(m)"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WpaPwEBeQutv",
        "outputId": "9fcf77f9-20d3-42b7-cf61-906cbd77dfbf"
      },
      "source": [
        "my_sub(5, 9)\n"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xYU098EtQwvn",
        "outputId": "2c3b8661-ab76-4b4f-bdea-78525d417009"
      },
      "source": [
        "my_sub(10, 30)\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "20"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jkRXNCMuQyyi",
        "outputId": "1e9f53d0-1c31-489b-8dc3-6f477d458241"
      },
      "source": [
        "my_sub(0, 0)\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cH7nxgVjQ2P3"
      },
      "source": [
        ">Q. 4. Create a function that takes a string containing money in dollars and pounds sterling (seperated by comma) and returns the sum of dollar bills only, as an integer.\n",
        "\n",
        "For the input string:\n",
        "\n",
        "   - Each amount is prefixed by the currency symbol: $ for dollars and £ for pounds.\n",
        "   - Thousands are represented by the suffix k.\n",
        "\n",
        "i.e. $4k = $4,000 and £40k = £40,000\n",
        "\n",
        "Examples\n",
        "\n",
        "add_bill(\"d20,p40,p60,d50\") ➞ 20 + 50 = 70\n",
        "\n",
        "add_bill(\"p30,d20,p60,d150,p360\") ➞ 20  + 150 = 170\n",
        "\n",
        "add_bill(\"p30,d2k,p60,d200,p360\") ➞ 2 * 1000 + 200 = 2200"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ABt4bDjfQ0D_"
      },
      "source": [
        "def add_bill(r):\n",
        "    n=[]\n",
        "    l =list(r.split(\",\"))\n",
        "    l=[i for i in l if i[0] == 'd']\n",
        "    l=[i[1:] for i in l if i[0] == 'd']\n",
        "    for i in l:\n",
        "        if \"k\" in i:\n",
        "            i = i[:-1]\n",
        "            i= int(i)*1000\n",
        "            n.append(i)\n",
        "        else:\n",
        "            n.append(int(i))\n",
        "    return sum(n)"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ffN6DQ8sQ5PZ",
        "outputId": "97ae9a0f-9913-4d49-87fc-6b6fa3addcad"
      },
      "source": [
        "add_bill(\"p30,d2k,p60,d200,p360\")\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2200"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TQXem827Q6bu",
        "outputId": "e1221c94-c021-4603-ddc1-7d18e127c7a9"
      },
      "source": [
        "add_bill(\"d20,p40,p60,d50\")\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "70"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BzO2dRymQ7mh",
        "outputId": "5a0e9381-d585-4c6e-90ec-6348f4d7776f"
      },
      "source": [
        "add_bill(\"p30,d20,p60,d150,p360\")\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "170"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z7747XlkRApT"
      },
      "source": [
        ">Q.5. Create a function that flips a horizontal list into a vertical list, and a vertical list into a horizontal list.\n",
        "\n",
        "In other words, take an 1 x n list (1 row + n columns) and flip it into a n x 1 list (n rows and 1 column), and vice versa.\n",
        "\n",
        "Examples\n",
        "\n",
        "flip_list([1, 2, 3, 4]) ➞ [[1], [2], [3], [4]]\n",
        "\n",
        " Take a horizontal list and flip it vertical.\n",
        "\n",
        "flip_list([[5], [6], [9]]) ➞ [5, 6, 9]\n",
        "\n",
        " Take a vertical list and flip it horizontal.\n",
        "\n",
        "flip_list([]) ➞ []"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cXE3FD-OQ8wH"
      },
      "source": [
        "def flip_list(l):\n",
        "    y = []\n",
        "    for i in l:\n",
        "        if type(i)!= list:\n",
        "            listA = [str(i)]\n",
        "            for elem in listA:\n",
        "               t = elem.split(', ')\n",
        "               y.append((t))\n",
        "        else:\n",
        "            y.append(i[0])\n",
        "    return y"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kIboifZ1RDse",
        "outputId": "9642a8b6-7704-4723-8d8d-e16aed84ec1a"
      },
      "source": [
        "flip_list([1, 2, 3, 4])\n"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[['1'], ['2'], ['3'], ['4']]"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hE_z5lXSRE2K",
        "outputId": "602fba55-68bc-4c54-a6d6-90121f9d7f4c"
      },
      "source": [
        "flip_list([[5], [6], [9]])\n"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5, 6, 9]"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-Wxv25QoRGA9",
        "outputId": "6145f6f7-fcb2-41b8-dfc3-d9affde5ef37"
      },
      "source": [
        "flip_list([])"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    }
  ]
}