Python Exercise (1-10).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Exercise -Version Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- This is the exercise based on the forked repository on GitHub\n",
    "-  Help to improve it if you want, just add the solution under the question\n",
    "- Each notebook only contains 10 questions which is convenient for everyone to locate each question to modify, you can add your own name under the author's list below, let's contribute together !\n",
    "- To visit my personal site: [Click Here](http://yaozeliang.com/resume)."
   ]
  },
 
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 1\n",
    "\n",
    "\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "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"
     ]
    }
   ],
   "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",
    "# l = [str(x) for x in range(2000,3201) if (x%7==0) and (x%5!=0)]  Better way\n",
    "print (','.join(l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "Suppose the following input is supplied to the program:\n",
    "8\n",
    "Then, the output should be:\n",
    "40320\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": {},
   "source": [
    "> Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fact(x):\n",
    "    if x == 0:\n",
    "        return 1\n",
    "    return x * fact(x - 1)\n",
    "x=int(input())\n",
    "print(fact(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as ma\n",
    "\"\"\"\n",
    "from functools import reduce\n",
    "from operator import mul\n",
    "\n",
    "x=int(input())\n",
    "print(reduce(mul,range(1,x+1)))\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "x=int(input())\n",
    "print(ma.factorial(x))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 3\n",
    "\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",
    "Suppose the following input is supplied to the program:\n",
    "8\n",
    "Then, the output should be:\n",
    "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}\n",
    "\n",
    "Hints:\n",
    "In case of input data being supplied to the question, it should be assumed to be a console input.\n",
    "Consider use dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "{1: 1, 2: 4, 3: 9}\n"
     ]
    }
   ],
   "source": [
    "n=int(input())\n",
    "d=dict()\n",
    "for i in range(1,n+1):\n",
    "    d[i]=i*i\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "{1: 1, 2: 4, 3: 9, 4: 16}\n"
     ]
    }
   ],
   "source": [
    "n=int(input())\n",
    "d={x:x*x for x in range(1,n+1)}\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 4\n",
    "\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",
    "Suppose the following input is supplied to the program:\n",
    "34,67,55,33,12,98\n",
    "Then, the output should be:\n",
    "['34', '67', '55', '33', '12', '98']\n",
    "('34', '67', '55', '33', '12', '98')\n",
    "\n",
    "Hints:\n",
    "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5,6,7\n",
      "List of values : ['5', '6', '7']\n",
      "Tuple of values : ('5', '6', '7')\n"
     ]
    }
   ],
   "source": [
    "values=input()\n",
    "l=values.split(\",\")\n",
    "t=tuple(l)\n",
    "print(f\"List of values : {l}\")\n",
    "print(f\"Tuple of values : {t}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 5\n",
    "\n",
    "\n",
    "Define a class which has at least two methods:\n",
    "getString: to get a string from console input\n",
    "printString: to print the string in upper case.\n",
    "Also please include simple test function to test the class methods.\n",
    "\n",
    "Hints:\n",
    "Use __init__ method to construct some parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class InputOutString:\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())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adfadf\n",
      "ADFADF\n"
     ]
    }
   ],
   "source": [
    "a = InputOutString()\n",
    "a.getString()\n",
    "a.printString()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 6\n",
    "\n",
    "\n",
    "Write a program that calculates and prints the value according to the given formula:\n",
    "Q = Square root of [(2 * C * D)/H]\n",
    "Following are the fixed values of C and H:\n",
    "C is 50. H is 30.\n",
    "D is the variable whose values should be input to your program in a comma-separated sequence.\n",
    "Example\n",
    "Let us assume the following comma separated input sequence is given to the program:\n",
    "100,150,180\n",
    "The output of the program should be:\n",
    "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input numbers comma-separated:23,4,5,6\n",
      "9,4,4,4\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "c=50\n",
    "h=30\n",
    "value = []\n",
    "items= [x for x in input(\"Input numbers comma-separated:\").split(',')]\n",
    "for d in items:\n",
    "    value.append(str(int(round(math.sqrt(2*c*float(d)/h)))))\n",
    "\n",
    "print (','.join(value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.\n",
    "Example\n",
    "Suppose the following inputs are given to the program:\n",
    "3,5\n",
    "Then, the output of the program should be:\n",
    "[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]] \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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4,5\n",
      "[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8], [0, 3, 6, 9, 12]]\n"
     ]
    }
   ],
   "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.Suppose the following input is supplied to the program:\n",
    "without,hello,bag,world\n",
    "\n",
    "Then, the output should be:\n",
    "bag,hello,without,world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input Text:final_string,adf,rt,yu\n",
      "adf,final_string,rt,yu\n"
     ]
    }
   ],
   "source": [
    "original_string = input(\"Input Text:\")\n",
    "l = original_string.split(\",\")\n",
    "final_string = sorted(l,key=str)\n",
    "print(','.join(final_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "Suppose the following input is supplied to the program:\n",
    "\n",
    "```\n",
    "Hello world\n",
    "Practice makes perfect\n",
    "```\n",
    "Then, the output should be:\n",
    "```\n",
    "HELLO WORLD\n",
    "PRACTICE MAKES PERFECT\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": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adf\n",
      "adfad\n",
      "adfas\n",
      "\n",
      "ADF\n",
      "ADFAD\n",
      "ADFAS\n"
     ]
    }
   ],
   "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)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 10\n",
    "\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",
    "Suppose the following input is supplied to the program:\n",
    "```\n",
    "hello world and practice makes perfect and hello world again\n",
    "```\n",
    "Then, the output should be:\n",
    "```\n",
    "again and hello makes perfect practice world\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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input Text:hello world and practice makes perfect and hello world again\n",
      "again and hello makes perfect practice world\n"
     ]
    }
   ],
   "source": [
    "s = input(\"Input Text:\")\n",
    "words = [word for word in s.split(\" \")]\n",
    "print (\" \".join(sorted(list(set(words)))))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}