11-20 Python challenging programming exercises(in Python 3x).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "11-20 Python challenging programming exercises ( in Python 3.x).ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyO5G+ZRjGhSREvDO9UzJu0Z",
      "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/abhayku2002/Python-programming-exercises/blob/master/11_20_Python_challenging_programming_exercises_(_in_Python_3_x).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dCYfUyWXVwxU"
      },
      "source": [
        "# **Question 11:**\n",
        "\n",
        "Write a program which accepts a sequence of comma separated 4 digit binary numbers as its input and then check whether they are divisible by 5 or not. The numbers that are divisible by 5 are to be printed in a comma separated sequence.\n",
        "\n",
        "Example:\n",
        "```\n",
        "  Input:  0100,0011,1010,1001\n",
        "\n",
        "  output: 1010\n",
        "```\n",
        "\n",
        "Notes: Assume the data is input by console.\n",
        "\n",
        "**Hints:\n",
        "In case of input data being supplied to the question, it should be assumed to be a console input.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YZE1RxkbanjK"
      },
      "source": [
        "# **Solution:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kHOUUqenVHWF",
        "outputId": "22c43a22-3398-401b-8dd1-7691a130a578",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "value = []\n",
        "items= [x for x in input().split(',')]\n",
        "for p in items:\n",
        "    intp = int(p, 2)\n",
        "    if not intp%5:\n",
        "        value.append(p)\n",
        "\n",
        "print(','.join(value))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0100,0011,1010,1001\n",
            "1010\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ITislaFibmei"
      },
      "source": [
        "# **Question 12:**\n",
        "\n",
        "Write a program, which will find all such numbers between 1000 and 3000 (both included) such that each digit of the number is an even number.\n",
        "The numbers obtained should be printed in a comma-separated sequence on a single line.\n",
        "\n",
        "**Hints:\n",
        "In case of input data being supplied to the question, it should be assumed to be a console input.**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lnSJxW8ecGTv"
      },
      "source": [
        "# **Solution:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bzmhG5ecb9gv",
        "outputId": "446500c4-41c1-4065-9ec7-454455c830ef",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "values = []\n",
        "for i in range(1000, 3001):\n",
        "    s = str(i)\n",
        "    if (int(s[1])%2==0) and (int(s[2])%2==0) and (int(s[3])%2==0):\n",
        "        values.append(s)\n",
        "print(\",\".join(values))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1000,1002,1004,1006,1008,1020,1022,1024,1026,1028,1040,1042,1044,1046,1048,1060,1062,1064,1066,1068,1080,1082,1084,1086,1088,1200,1202,1204,1206,1208,1220,1222,1224,1226,1228,1240,1242,1244,1246,1248,1260,1262,1264,1266,1268,1280,1282,1284,1286,1288,1400,1402,1404,1406,1408,1420,1422,1424,1426,1428,1440,1442,1444,1446,1448,1460,1462,1464,1466,1468,1480,1482,1484,1486,1488,1600,1602,1604,1606,1608,1620,1622,1624,1626,1628,1640,1642,1644,1646,1648,1660,1662,1664,1666,1668,1680,1682,1684,1686,1688,1800,1802,1804,1806,1808,1820,1822,1824,1826,1828,1840,1842,1844,1846,1848,1860,1862,1864,1866,1868,1880,1882,1884,1886,1888,2000,2002,2004,2006,2008,2020,2022,2024,2026,2028,2040,2042,2044,2046,2048,2060,2062,2064,2066,2068,2080,2082,2084,2086,2088,2200,2202,2204,2206,2208,2220,2222,2224,2226,2228,2240,2242,2244,2246,2248,2260,2262,2264,2266,2268,2280,2282,2284,2286,2288,2400,2402,2404,2406,2408,2420,2422,2424,2426,2428,2440,2442,2444,2446,2448,2460,2462,2464,2466,2468,2480,2482,2484,2486,2488,2600,2602,2604,2606,2608,2620,2622,2624,2626,2628,2640,2642,2644,2646,2648,2660,2662,2664,2666,2668,2680,2682,2684,2686,2688,2800,2802,2804,2806,2808,2820,2822,2824,2826,2828,2840,2842,2844,2846,2848,2860,2862,2864,2866,2868,2880,2882,2884,2886,2888,3000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RX9yhRAUeHS8"
      },
      "source": [
        "# **Question 13:**\n",
        "Write a program that accepts a sentence and calculate the number of letters and digits.\n",
        "\n",
        "Suppose the following input is supplied to the program:\n",
        "```\n",
        "hello world! 123\n",
        "```\n",
        "Then, the output should be:\n",
        "```\n",
        "LETTERS 10\n",
        "DIGITS 3\n",
        "```\n",
        "**Hints:\n",
        "In case of input data being supplied to the question, it should be assumed to be a console input.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2fdpNfBhfxCG"
      },
      "source": [
        "# **Solution:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-mXwVxIfeSVl",
        "outputId": "4cd2456e-6d23-420a-ddab-6d228b8c1d1b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "s = input()\n",
        "d={\"DIGITS\":0, \"LETTERS\":0}\n",
        "for c in s:\n",
        "    if c.isdigit():\n",
        "        d[\"DIGITS\"]+=1\n",
        "    elif c.isalpha():\n",
        "        d[\"LETTERS\"]+=1\n",
        "    else:\n",
        "        pass\n",
        "print(\"LETTERS\", d[\"LETTERS\"])\n",
        "print(\"DIGITS\", d[\"DIGITS\"])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello world! 123\n",
            "LETTERS 10\n",
            "DIGITS 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GVawfKVogCK-"
      },
      "source": [
        "\n",
        "# **Question 14:**\n",
        "Write a program that accepts a sentence and calculate the number of upper case letters and lower case letters.\n",
        "\n",
        "Suppose the following input is supplied to the program:\n",
        "```\n",
        "Hello world!\n",
        "```\n",
        "Then, the output should be:\n",
        "```\n",
        "UPPER CASE 1\n",
        "LOWER CASE 9\n",
        "```\n",
        "Hints:\n",
        "In case of input data being supplied to the question, it should be assumed to be a console input.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s9RwdUKphTh6"
      },
      "source": [
        "# **Solution:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h-crG-T8gXnH",
        "outputId": "329972e9-9425-4e9d-977b-bedea5ca3198",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "s = input()\n",
        "d={\"UPPER CASE\":0, \"LOWER CASE\":0}\n",
        "for c in s:\n",
        "    if c.isupper():\n",
        "        d[\"UPPER CASE\"]+=1\n",
        "    elif c.islower():\n",
        "        d[\"LOWER CASE\"]+=1\n",
        "    else:\n",
        "        pass\n",
        "print(\"UPPER CASE\", d[\"UPPER CASE\"])\n",
        "print(\"LOWER CASE\", d[\"LOWER CASE\"])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello World!\n",
            "UPPER CASE 2\n",
            "LOWER CASE 8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GyaeC9XwhYqM"
      },
      "source": [
        "# **Question 15:**\n",
        "Write a program that computes the value of a+aa+aaa+aaaa with a given digit as the value of a.\n",
        "Suppose the following input is supplied to the program:\n",
        "```\n",
        "9\n",
        "```\n",
        "Then, the output should be:\n",
        "```\n",
        "11106\n",
        "```\n",
        "**Hints:\n",
        "In case of input data being supplied to the question, it should be assumed to be a console input.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eCsb8M-GhsWG"
      },
      "source": [
        "# **Solution:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fZInGI0YhnwE",
        "outputId": "945d5235-f439-48a8-85cd-2640890cfca2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "a = input()\n",
        "n1 = int( \"%s\" % a )\n",
        "n2 = int( \"%s%s\" % (a,a) )\n",
        "n3 = int( \"%s%s%s\" % (a,a,a) )\n",
        "n4 = int( \"%s%s%s%s\" % (a,a,a,a) )\n",
        "print(n1+n2+n3+n4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "9\n",
            "11106\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3PpK3qafiTwz"
      },
      "source": [
        "# **Question 16:**\n",
        "Use a list comprehension to square each odd number in a list. The list is input by a sequence of comma-separated numbers.\n",
        "\n",
        "Suppose the following input is supplied to the program:\n",
        "```\n",
        "1,2,3,4,5,6,7,8,9\n",
        "```\n",
        "Then, the output should be:\n",
        "```\n",
        "1,3,5,7,9\n",
        "```\n",
        "**Hints:\n",
        "In case of input data being supplied to the question, it should be assumed to be a console input.**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a62ymVFXiyGx"
      },
      "source": [
        "# **Solution:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M0ivNxNOidki",
        "outputId": "dff76cff-0849-43c0-8415-c825f0cdefd5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "values = input()\n",
        "numbers = [x for x in values.split(\",\") if int(x)%2!=0]\n",
        "print(\",\".join(numbers))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1,2,3,4,5,6,7,8,9\n",
            "1,3,5,7,9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kPvEPe00jCEF"
      },
      "source": [
        "# **Question 17:**\n",
        "Write a program that computes the net amount of a bank account based a transaction log from console input. The transaction log format is shown as following:\n",
        "\n",
        "D 100\n",
        "\n",
        "W 200\n",
        "\n",
        "D means deposit while W means withdrawal.\n",
        "\n",
        "Suppose the following input is supplied to the program:\n",
        "```\n",
        "D 300\n",
        "D 300\n",
        "W 200\n",
        "D 100\n",
        "```\n",
        "\n",
        "Then, the output should be:\n",
        "```\n",
        "500\n",
        "```\n",
        "**Hints:\n",
        "In case of input data being supplied to the question, it should be assumed to be a console input.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XvUkZfmZj5He"
      },
      "source": [
        "# **Solution:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uprZugDYjPJ6",
        "outputId": "538efebe-4097-4ed1-844a-2975906aec0a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        }
      },
      "source": [
        "netAmount = 0\n",
        "while True:\n",
        "    s = input()\n",
        "    if not s:\n",
        "        break\n",
        "    values = s.split(\" \")\n",
        "    operation = values[0]\n",
        "    amount = int(values[1])\n",
        "    if operation==\"D\":\n",
        "        netAmount+=amount\n",
        "    elif operation==\"W\":\n",
        "        netAmount-=amount\n",
        "    else:\n",
        "        pass\n",
        "print(netAmount)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "D 300\n",
            "D 300\n",
            "W 200\n",
            "D 100\n",
            "\n",
            "500\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GszEpE98seP1"
      },
      "source": [
        "# **Question 18:**\n",
        "A website requires the users to input username and password to register. Write a program to check the validity of password input by users.\n",
        "Following are the criteria for checking the password:\n",
        "1. At least 1 letter between [a-z]\n",
        "2. At least 1 number between [0-9]\n",
        "1. At least 1 letter between [A-Z]\n",
        "3. At least 1 character from [$#@]\n",
        "4. Minimum length of transaction password: 6\n",
        "5. Maximum length of transaction password: 12\n",
        "Your program should accept a sequence of comma separated passwords and will check them according to the above criteria. Passwords that match the criteria are to be printed, each separated by a comma.\n",
        "\n",
        "Example:\n",
        "\n",
        "If the following passwords are given as input to the program:\n",
        "```\n",
        "ABd1234@1,a F1#,2w3E*,2We3345\n",
        "```\n",
        "Then, the output of the program should be:\n",
        "```\n",
        "ABd1234@1\n",
        "```\n",
        "**Hints:\n",
        "In case of input data being supplied to the question, it should be assumed to be a console input.**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GVBp_rXdtJ-5"
      },
      "source": [
        "# **Solutions:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SmzpO2BUssa4",
        "outputId": "d8164f55-649e-4991-9bc8-dbd7e2106b93",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "import re\n",
        "value = []\n",
        "items=[x for x in input().split(',')]\n",
        "for p in items:\n",
        "    if len(p)<6 or len(p)>12:\n",
        "        continue\n",
        "    else:\n",
        "        pass\n",
        "    if not re.search(\"[a-z]\",p):\n",
        "        continue\n",
        "    elif not re.search(\"[0-9]\",p):\n",
        "        continue\n",
        "    elif not re.search(\"[A-Z]\",p):\n",
        "        continue\n",
        "    elif not re.search(\"[$#@]\",p):\n",
        "        continue\n",
        "    elif re.search(\"\\s\",p):\n",
        "        continue\n",
        "    else:\n",
        "        pass\n",
        "    value.append(p)\n",
        "print(\",\".join(value))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ABd1234@1,a F1#,2w3E*,2We3345\n",
            "ABd1234@1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0srCj1jruHvD"
      },
      "source": [
        "# **Question 19:**\n",
        "You are required to write a program to sort the (name, age, height) tuples by ascending order where name is string, age and height are numbers. The tuples are input by console. The sort criteria is:\n",
        "\n",
        "1: Sort based on name;\n",
        "\n",
        "2: Then sort based on age;\n",
        "\n",
        "3: Then sort by score.\n",
        "\n",
        "The priority is that name > age > score.\n",
        "If the following tuples are given as input to the program:\n",
        "```\n",
        "Tom,19,80\n",
        "John,20,90\n",
        "Jony,17,91\n",
        "Jony,17,93\n",
        "Json,21,85\n",
        "```\n",
        "Then, the output of the program should be:\n",
        "```\n",
        "[('John', '20', '90'), ('Jony', '17', '91'), ('Jony', '17', '93'), ('Json', '21', '85'), ('Tom', '19', '80')]\n",
        "```\n",
        "**Hints:\n",
        "In case of input data being supplied to the question, it should be assumed to be a console input.\n",
        "We use itemgetter to enable multiple sort keys.**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bier0x-guwvS"
      },
      "source": [
        "# **Solutions:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X9vwlMiluWcE",
        "outputId": "c940b685-ca58-448f-fc33-0bf91260dfeb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        }
      },
      "source": [
        "from operator import itemgetter, attrgetter\n",
        "l = []\n",
        "while True:\n",
        "    s = input()\n",
        "    if not s:\n",
        "        break\n",
        "    l.append(tuple(s.split(\",\")))\n",
        "print(sorted(l, key=itemgetter(0,1,2)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Tom,19,80\n",
            "John,20,90\n",
            "Jony,17,91\n",
            "Jony,17,93\n",
            "Json,21,85\n",
            "\n",
            "[('John', '20', '90'), ('Jony', '17', '91'), ('Jony', '17', '93'), ('Json', '21', '85'), ('Tom', '19', '80')]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O84F8m1Rwjbi"
      },
      "source": [
        "# **Question 20:**\n",
        "Define a class with a generator which can iterate the numbers, which are divisible by 7, between a given range 0 and n.\n",
        "\n",
        "**Hints:\n",
        "Consider use yield**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H3aZ9vglwxoB"
      },
      "source": [
        "# **Solution:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i6Muna7GwtPX",
        "outputId": "840c2f0f-718d-42ac-d202-f3d19713f709",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 272
        }
      },
      "source": [
        "def putNumbers(n):\n",
        "    i = 0\n",
        "    while i<n:\n",
        "        j=i\n",
        "        i=i+1\n",
        "        if j%7==0:\n",
        "            yield j\n",
        "putNumbers(i)\n",
        "for i in putNumbers(100):\n",
        "  print(i)"
      ],
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "7\n",
            "14\n",
            "21\n",
            "28\n",
            "35\n",
            "42\n",
            "49\n",
            "56\n",
            "63\n",
            "70\n",
            "77\n",
            "84\n",
            "91\n",
            "98\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}