1-10 Python Programming Exercise ( in Python 3.x ).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "0-10 Python challenging programming exercises ( in Python 3.x ).ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "metadata": {
        "id": "3cNRoIuf3t_0",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# 1-10 Python challenging programming exercises <br>\n",
        "# ( in Python 3.x)"
      ]
    },
    {
      "metadata": {
        "id": "jGZXCsmh3zk5",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Question 1 :\n",
        "Write a program which will find all such numbers which are divisible by 7 but are not a multiple of 5,\n",
        "between 2000 and 3200 (both included).\n",
        "The numbers obtained should be printed in a comma-separated sequence on a single line.\n",
        "\n",
        "**Hints: \n",
        "Consider use range(#begin, #end) method**\n"
      ]
    },
    {
      "metadata": {
        "id": "-Y7hzQih4FyZ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Solution:\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "ZXQA9GEO2wAH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "acc5ff9e-c3bc-4e92-a2a3-5363aed4cd2d"
      },
      "cell_type": "code",
      "source": [
        "l=[]\n",
        "for i in range(2000, 3201):\n",
        "    if (i%7==0) and (i%5!=0):\n",
        "        l.append(str(i))\n",
        "\n",
        "print (','.join(l))"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2002,2009,2016,2023,2037,2044,2051,2058,2072,2079,2086,2093,2107,2114,2121,2128,2142,2149,2156,2163,2177,2184,2191,2198,2212,2219,2226,2233,2247,2254,2261,2268,2282,2289,2296,2303,2317,2324,2331,2338,2352,2359,2366,2373,2387,2394,2401,2408,2422,2429,2436,2443,2457,2464,2471,2478,2492,2499,2506,2513,2527,2534,2541,2548,2562,2569,2576,2583,2597,2604,2611,2618,2632,2639,2646,2653,2667,2674,2681,2688,2702,2709,2716,2723,2737,2744,2751,2758,2772,2779,2786,2793,2807,2814,2821,2828,2842,2849,2856,2863,2877,2884,2891,2898,2912,2919,2926,2933,2947,2954,2961,2968,2982,2989,2996,3003,3017,3024,3031,3038,3052,3059,3066,3073,3087,3094,3101,3108,3122,3129,3136,3143,3157,3164,3171,3178,3192,3199\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "oZUKUnua4ZnB",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Question 2 :\n",
        "\n",
        "Write a program which can compute the factorial of a given numbers.\n",
        "The results should be printed in a comma-separated sequence on a single line.\n",
        "Example:\n",
        "\n",
        "\n",
        "```\n",
        "Input: 8\n",
        "Output: 40320\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "**Hints: In case of input data being supplied to the question, it should be assumed to be a console input.**"
      ]
    },
    {
      "metadata": {
        "id": "oAS1xnsI5Gc4",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Solution : "
      ]
    },
    {
      "metadata": {
        "id": "yBnKhW4N48P_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "7ca43d17-69eb-4687-e70e-e3512ebc5a1f"
      },
      "cell_type": "code",
      "source": [
        "def fact(x):\n",
        "    if x == 0:\n",
        "        return 1\n",
        "    return x * fact(x - 1)\n",
        "\n",
        "x=int(input())\n",
        "print (fact(x))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8\n",
            "40320\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "CpLlpqwh5TYL",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Question 3 :\n",
        "With a given integral number n, write a program to generate a dictionary that contains (i, i*i) such that is an integral number between 1 and n (both included) and then the program should print the dictionary.\n",
        "Example: \n",
        "\n",
        "\n",
        "```\n",
        "Input: 8\n",
        "Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}\n",
        "```\n",
        "\n",
        "**Hints: In case of input data being supplied to the question, it should be assumed to be a console input and consider use dict()**"
      ]
    },
    {
      "metadata": {
        "id": "JYxUpjSP6nhP",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Solution : "
      ]
    },
    {
      "metadata": {
        "id": "lBlzWq2Z6dwS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "9c5f831e-273d-4123-e1a2-290631039f56"
      },
      "cell_type": "code",
      "source": [
        "n=int(input())\n",
        "d=dict()\n",
        "for i in range(1,n+1):\n",
        "    d[i]=i*i\n",
        "\n",
        "print (d)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8\n",
            "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "FL2akaO_6w8X",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Question 4 :\n",
        "Write a program which accepts a sequence of comma-separated numbers from console and generate a list and a tuple which contains every number.\n",
        "Example:\n",
        "\n",
        "\n",
        "```\n",
        "Input: 34,67,55,33,12,98\n",
        "Output: ['34', '67', '55', '33', '12', '98']\n",
        "        ('34', '67', '55', '33', '12', '98')\n",
        "```\n",
        "\n",
        " **Hints: In case of input data being supplied to the question, it should be assumed to be a console input.\n",
        "tuple() method can convert list to tuple**"
      ]
    },
    {
      "metadata": {
        "id": "DVC8Uf9d7bdt",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Solution : "
      ]
    },
    {
      "metadata": {
        "id": "E_N1w8FG7dDW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "90d0f6a0-daa7-4f1a-d48e-cb842837a65f"
      },
      "cell_type": "code",
      "source": [
        "values= input()\n",
        "l=values.split(\",\")\n",
        "t=tuple(l)\n",
        "print (l)\n",
        "print (t)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "34,67,55,33,12,98\n",
            "['34', '67', '55', '33', '12', '98']\n",
            "('34', '67', '55', '33', '12', '98')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "jdy5hMu07xPS",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Question 5 :\n",
        "Define a class which has at least two methods:\n",
        "\n",
        "\n",
        "```\n",
        "getString: to get a string from console input\n",
        "printString: to print the string in upper case.\n",
        "```\n",
        "\n",
        "\n",
        "Also please include simple test function to test the class methods.\n",
        "Example:\n",
        "\n",
        "\n",
        "```\n",
        "Input : HelloWorld\n",
        "Output: HELLOWORLD\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "**Hints: Use __init__ method to construct some parameters**"
      ]
    },
    {
      "metadata": {
        "id": "veR7ECN88HA8",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Solution :"
      ]
    },
    {
      "metadata": {
        "id": "Mrd31rk68I65",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "fe5d4e57-2d51-4423-89bc-8defd8d8a06e"
      },
      "cell_type": "code",
      "source": [
        "class InputOutString(object):\n",
        "    def __init__(self):\n",
        "        self.s = \"\"\n",
        "\n",
        "    def getString(self):\n",
        "        self.s = input()\n",
        "\n",
        "    def printString(self):\n",
        "        print (self.s.upper())\n",
        "\n",
        "strObj = InputOutString()\n",
        "strObj.getString()\n",
        "strObj.printString()"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "HelloWorld\n",
            "HELLOWORLD\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "QHObDG5cWYle",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Question 6 : \n",
        "\n",
        "Question:\n",
        "Write a program that calculates and prints the value according to the given formula: <br>\n",
        "Q = Square root of (2*C*D/ H) <br>\n",
        "Following are the fixed values of C and H:<br>\n",
        "C is 50. H is 30.<br>\n",
        "D is the variable whose values should be input to your program in a comma-separated sequence.<br>\n",
        "\n",
        "```\n",
        "Example: \n",
        "\n",
        "Input: 100,150,180\n",
        "Output: 18,22,24\n",
        "```\n",
        "**Hints:\n",
        "If the output received is in decimal form, it should be rounded off to its nearest value (for example, if the output received is 26.0, it should be printed as 26)\n",
        "In case of input data being supplied to the question, it should be assumed to be a console input.**\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "etJhrZraYu4m",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Solution : "
      ]
    },
    {
      "metadata": {
        "id": "RBcL4qZtYurF",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "6e7d5060-7c9c-4552-9383-f0e488452e19"
      },
      "cell_type": "code",
      "source": [
        "#!/usr/bin/env python\n",
        "import math\n",
        "c=50\n",
        "h=30\n",
        "value = []\n",
        "items=[x for x in input().split(',')]\n",
        "for d in items:\n",
        "    value.append(str(int(round(math.sqrt(2*c*float(d)/h)))))\n",
        "\n",
        "print (','.join(value))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100,150,180\n",
            "18,22,24\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "56vA73u1ZQKV",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        ""
      ]
    },
    {
      "metadata": {
        "id": "25f7txxUZUFy",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Question 7 :\n",
        "\n",
        "Write a program which takes 2 digits, X,Y as input and generates a 2-dimensional array. The element value in the i-th row and j-th column of the array should be i*j.\n",
        "**Note: i=0,1.., X-1; j=0,1,Y-1**<br>\n",
        "\n",
        "\n",
        "```\n",
        "Example:\n",
        "Input: 3,5\n",
        "Output: [[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]\n",
        "```\n",
        "\n",
        " **Hints:\n",
        "Note: In case of input data being supplied to the question, it should be assumed to be a console input in a comma-separated form.**"
      ]
    },
    {
      "metadata": {
        "id": "-ymNMuPpaEIs",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Solution :"
      ]
    },
    {
      "metadata": {
        "id": "RLmwx_BUWO8_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "b73c13f5-0b9d-4e68-8e91-08482fa49a3f"
      },
      "cell_type": "code",
      "source": [
        "input_str = input()\n",
        "dimensions=[int(x) for x in input_str.split(',')]\n",
        "rowNum=dimensions[0]\n",
        "colNum=dimensions[1]\n",
        "multilist = [[0 for col in range(colNum)] for row in range(rowNum)]\n",
        "\n",
        "for row in range(rowNum):\n",
        "    for col in range(colNum):\n",
        "        multilist[row][col]= row*col\n",
        "\n",
        "print (multilist)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3, 5\n",
            "[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "yQWf89hNaiHt",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Question 8 :\n",
        "\n",
        "Write a program that accepts a comma separated sequence of words as input and prints the words in a comma-separated sequence after sorting them alphabetically.\n",
        "\n",
        "\n",
        "```\n",
        "Example: \n",
        "Input: without,hello,bag,world\n",
        "Output: bag,hello,without,world\n",
        "```\n",
        "\n",
        "**Hints:\n",
        "In case of input data being supplied to the question, it should be assumed to be a console input.**"
      ]
    },
    {
      "metadata": {
        "id": "1aS3YHfVa6XJ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Solution : "
      ]
    },
    {
      "metadata": {
        "id": "8hWq8w_PaH36",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "e7d895ae-73b7-405b-92f5-fbeec8c6e5e6"
      },
      "cell_type": "code",
      "source": [
        "items=[x for x in input().split(',')]\n",
        "items.sort()\n",
        "print (','.join(items))"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "without,hello,bag,world\n",
            "bag,hello,without,world\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "j23c1wwpbLsZ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Question 9 :\n",
        "\n",
        "Write a program that accepts sequence of lines as input and prints the lines after making all characters in the sentence capitalized.\n",
        "\n",
        "\n",
        "```\n",
        "Example:\n",
        "Input1 : Hello world        Input2: Practice makes perfect\n",
        "Output1 : HELLO WORLD       Output2: PRACTICE MAKES PERFECT\n",
        "```\n",
        "** Hints: In case of input data being supplied to the question, it should be assumed to be a console input.**\n"
      ]
    },
    {
      "metadata": {
        "id": "BcDsAD7bbpbi",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Solution : "
      ]
    },
    {
      "metadata": {
        "id": "IXd7_Dfib5eb",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "c4e6272d-e4f6-4fa1-f05c-d6e50d763fca"
      },
      "cell_type": "code",
      "source": [
        "lines = []\n",
        "while True:\n",
        "    s = input()\n",
        "    if s:\n",
        "        lines.append(s.upper())\n",
        "    else:\n",
        "        break;\n",
        "        \n",
        "for sentence in lines:\n",
        "    print (sentence)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello world\n",
            "Practice makes perfect\n",
            "\n",
            "HELLO WORLD\n",
            "PRACTICE MAKES PERFECT\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "2OQVzhsUcjx_",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Question 10 :\n",
        "Write a program that accepts a sequence of whitespace separated words as input and prints the words after removing all duplicate words and sorting them alphanumerically.\n",
        " \n",
        "\n",
        "```\n",
        "Example: \n",
        "Input : hello world and practice makes perfect and hello world again\n",
        "Output : again and hello makes perfect practice world\n",
        "```\n",
        "\n",
        "\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 set container to remove duplicated data automatically and then use sorted() to sort the data.**\n"
      ]
    },
    {
      "metadata": {
        "id": "sQHZH_dVc7py",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Solution :"
      ]
    },
    {
      "metadata": {
        "id": "t_LQR1TZc-EO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "44a2c9cf-5e8f-40ac-f7a4-03c9d9f09c3a"
      },
      "cell_type": "code",
      "source": [
        "s = input()\n",
        "words = [word for word in s.split(\" \")]\n",
        "print (' '.join(sorted(list(set(words))))) "
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello world and practice makes perfect and hello world again\n",
            "again and hello makes perfect practice world\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}