Python Exercise (21-30).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Exercise Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 21\n",
    "\n",
    "\n",
    ">***A robot moves in a plane starting from the original point (0,0). The robot can move toward UP, DOWN, LEFT and RIGHT with a given steps. The trace of robot movement is shown as the following:***\n",
    "```\n",
    "UP 5\n",
    "DOWN 3\n",
    "LEFT 3\n",
    "RIGHT 2\n",
    "```\n",
    ">***The numbers after the direction are steps. Please write a program to compute the distance from current position after a sequence of movement and original point. If the distance is a float, then just print the nearest integer.***\n",
    "***Example:***\n",
    "***If the following tuples are given as input to the program:***\n",
    "```\n",
    "UP 5\n",
    "DOWN 3\n",
    "LEFT 3\n",
    "RIGHT 2\n",
    "```\n",
    ">***Then, the output of the program should be:***\n",
    "```\n",
    "2\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UP 5\n",
      "\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "import  math\n",
    "\n",
    "x,y = 0,0\n",
    "while True:\n",
    "    s = input().split()\n",
    "    if not s:\n",
    "        break\n",
    "    if s[0]=='UP':                  # s[0] indicates command\n",
    "        x-=int(s[1])                # s[1] indicates unit of move\n",
    "    if s[0]=='DOWN':\n",
    "        x+=int(s[1])\n",
    "    if s[0]=='LEFT':\n",
    "        y-=int(s[1])\n",
    "    if s[0]=='RIGHT':\n",
    "        y+=int(s[1])\n",
    "                                    # N**P means N^P\n",
    "dist = round(math.sqrt(x**2 + y**2))  # euclidean distance = square root of (x^2+y^2) and rounding it to nearest integer\n",
    "print(dist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 22\n",
    "\n",
    ">***Write a program to compute the frequency of the words from the input. The output should output after sorting the key alphanumerically.***\n",
    "\n",
    ">***Suppose the following input is supplied to the program:***\n",
    "```\n",
    "New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.\n",
    "```\n",
    ">***Then, the output should be:***\n",
    "```\n",
    "2:2\n",
    "3.:1\n",
    "3?:1\n",
    "New:1\n",
    "Python:5\n",
    "Read:1\n",
    "and:1\n",
    "between:1\n",
    "choosing:1\n",
    "or:2\n",
    "to:1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.\n",
      "2:2\n",
      "3.:1\n",
      "3?:1\n",
      "New:1\n",
      "Python:5\n",
      "Read:1\n",
      "and:1\n",
      "between:1\n",
      "choosing:1\n",
      "or:2\n",
      "to:1\n"
     ]
    }
   ],
   "source": [
    "ss = input().split()\n",
    "word = sorted(set(ss))     # split words are stored and sorted as a set\n",
    "\n",
    "for i in word:\n",
    "    print(\"{0}:{1}\".format(i,ss.count(i)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.\n",
      "2:2\n",
      "3.:1\n",
      "3?:1\n",
      "New:1\n",
      "Python:5\n",
      "Read:1\n",
      "and:1\n",
      "between:1\n",
      "choosing:1\n",
      "or:2\n",
      "to:1\n"
     ]
    }
   ],
   "source": [
    "ss = input().split()\n",
    "dict = {}\n",
    "for i in ss:\n",
    "    i = dict.setdefault(i,ss.count(i))    # setdefault() function takes key & value to set it as dictionary.\n",
    "\n",
    "dict = sorted(dict.items())               # items() function returns both key & value of dictionary as a list\n",
    "                                          # and then sorted. The sort by default occurs in order of 1st -> 2nd key\n",
    "for i in dict:\n",
    "    print(\"%s:%d\"%(i[0],i[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "from collections import Counter\n",
      "Counter:1\n",
      "collections:1\n",
      "from:1\n",
      "import:1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('Counter', 1), ('collections', 1), ('from', 1), ('import', 1)]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "ss = input().split()\n",
    "my_dict = Counter(ss)         # returns key & frequency as a dictionary\n",
    "result = sorted(my_dict.items())  # returns as a tuple list\n",
    "\n",
    "for i in result:\n",
    "    print(\"%s:%d\"%(i[0],i[1]))\n",
    "\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 23\n",
    "\n",
    ">***Write a method which can calculate square value of number***\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "def square(num):\n",
    "    return num ** 2\n",
    "\n",
    "print(square(2))\n",
    "print(square(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 24\n",
    "\n",
    "\n",
    ">***Python has many built-in functions, and if you do not know how to use it, you can read document online or find some books. But Python has a built-in document function for every built-in functions.***\n",
    "\n",
    ">***Please write a program to print some Python built-in functions documents, such as abs(), int(), raw_input()***\n",
    "\n",
    ">***And add document for your own function***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Return the absolute value of the argument.\n",
      "int([x]) -> integer\n",
      "int(x, base=10) -> integer\n",
      "\n",
      "Convert a number or string to an integer, or return 0 if no arguments\n",
      "are given.  If x is a number, return x.__int__().  For floating point\n",
      "numbers, this truncates towards zero.\n",
      "\n",
      "If x is not a number or if base is given, then x must be a string,\n",
      "bytes, or bytearray instance representing an integer literal in the\n",
      "given base.  The literal can be preceded by '+' or '-' and be surrounded\n",
      "by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.\n",
      "Base 0 means to interpret the base from the string as an integer literal.\n",
      ">>> int('0b100', base=0)\n",
      "4\n",
      "4\n",
      "\n",
      "    Return the square value of the input number.\n",
      "    The input number must be integer.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print (abs.__doc__)\n",
    "print (int.__doc__)\n",
    "\n",
    "def square(num):\n",
    "    '''\n",
    "    Return the square value of the input number.\n",
    "    The input number must be integer.\n",
    "    '''\n",
    "    return num ** 2\n",
    "\n",
    "print (square(2))\n",
    "print (square.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 25\n",
    "\n",
    "\n",
    ">***Define a class, which have a class parameter and have a same instance parameter.***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car name is Honda\n",
      "Car name is Toyota\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    name = \"Car\"\n",
    "\n",
    "    def __init__(self,name = None):\n",
    "        self.name = name\n",
    "\n",
    "honda=Car(\"Honda\")\n",
    "print(\"%s name is %s\"%(Car.name,honda.name))\n",
    "\n",
    "toyota=Car()\n",
    "toyota.name=\"Toyota\"\n",
    "print(\"%s name is %s\"%(Car.name,toyota.name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person name is Jeffrey\n",
      "Person name is Nico\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    # Define the class parameter \"name\"\n",
    "    name = \"Person\"\n",
    "    \n",
    "    def __init__(self, name = None):\n",
    "        # self.name is the instance parameter\n",
    "        self.name = name\n",
    "\n",
    "jeffrey = Person(\"Jeffrey\")\n",
    "print (\"{0} name is {1}\".format(Person.name, jeffrey.name))\n",
    "\n",
    "nico = Person()\n",
    "nico.name = \"Nico\"\n",
    "print (f\"{Person.name} name is {nico.name}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 26\n",
    "\n",
    ">***Define a function which can compute the sum of two numbers.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "sum = lambda n1,n2 : n1 + n2      # here lambda is use to define little function as sum\n",
    "print(sum(1,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 27\n",
    "\n",
    ">***Define a function that can convert a integer into a string and print it in console.***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "conv = lambda x : str(x)\n",
    "n = conv(10)\n",
    "print(n)\n",
    "print(type(n))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "def printValue(n):\n",
    "    print(str(n))\n",
    "\n",
    "printValue(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 28\n",
    "\n",
    ">***Define a function that can receive two integer numbers in string form and compute their sum and then print it in console.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "sum = lambda s1,s2 : int(s1) + int(s2)\n",
    "print(sum(\"10\",\"45\"))      # 55"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 29\n",
    "\n",
    ">***Define a function that can accept two strings as input and concatenate them and then print it in console.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1045\n"
     ]
    }
   ],
   "source": [
    "sum = lambda s1,s2 : s1 + s2\n",
    "print(sum(\"10\",\"45\"))        # 1045\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 30\n",
    "\n",
    ">***Define a function that can accept two strings as input and print the string with maximum length in console. If two strings have the same length, then the function should print all strings line by line.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adf   oiiuu\n",
      "oiiuu\n"
     ]
    }
   ],
   "source": [
    "def printVal(s1,s2):\n",
    "    len1 = len(s1)\n",
    "    len2 = len(s2)\n",
    "    if len1 > len2:\n",
    "        print(s1)\n",
    "    elif len1 < len2:\n",
    "        print(s2)\n",
    "    else:\n",
    "        print(s1)\n",
    "        print(s2)\n",
    "\n",
    "s1,s2=input().split()\n",
    "printVal(s1,s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}