codekatas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Question:\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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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",
    "print(','.join(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "3628800\n"
     ]
    }
   ],
   "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": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}\n"
     ]
    }
   ],
   "source": [
    "p_dict = {}\n",
    "n = int(input())\n",
    "for i in range(1,n+1):\n",
    "    p_dict[i] = i*i\n",
    "print(p_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "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"
     ]
    }
   ],
   "source": [
    "    csl = input('--->')\n",
    "    val_list = csl.split(',')\n",
    "    val_tuple = tuple(val_list)\n",
    "    print(val_list)\n",
    "    print(val_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Question:\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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "motherfucker\n",
      "MOTHERFUCKER\n"
     ]
    }
   ],
   "source": [
    "class two_method_class(object):\n",
    "    def __init__(self):\n",
    "        self.s = \"\"\n",
    "    def getString(self):\n",
    "        self.s = input()\n",
    "    def printString(self):\n",
    "        print(self.s.upper())\n",
    "two_method_obj = two_method_class()\n",
    "two_method_obj.getString()\n",
    "two_method_obj.printString()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Question:\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100,150,180\n",
      "18,22,24\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "D = [x for x in input().split(',')]\n",
    "C = 50\n",
    "H = 30\n",
    "l = []\n",
    "for d in D:\n",
    "    l.append(str(int(round(math.sqrt(2 * C * float(d)/H)))))\n",
    "print(','.join(l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "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]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3,4\n",
      "[[0, 0, 0, 0], [0, 1, 2, 3], [0, 2, 4, 6]]\n"
     ]
    }
   ],
   "source": [
    "R,C = [int(z) for z in input().split(',')]\n",
    "mat = [[row*col for col in range(C)] for row in range(R)]\n",
    "print(mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "Suppose the following input is supplied to the program:\n",
    "\n",
    "without,hello,bag,world\n",
    "\n",
    "Then, the output should be:\n",
    "bag,hello,without,world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "without,hello,bag,world\n",
      "['bag', 'hello', 'without', 'world']\n"
     ]
    }
   ],
   "source": [
    "s = input().split(',')\n",
    "s.sort()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that accepts sequence of lines as input and prints the lines after making all characters in the sentence capitalized.\n",
    "\n",
    "Suppose the following input is supplied to the program:\n",
    "\n",
    "Hello world\n",
    "Practice makes perfect\n",
    "\n",
    "Then, the output should be:\n",
    "HELLO WORLD\n",
    "PRACTICE MAKES PERFECT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world Practice makes perfect\n",
      "HELLO WORLD PRACTICE MAKES PERFECT\n"
     ]
    }
   ],
   "source": [
    "str = input()\n",
    "print(str.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world and practice makes perfect and hello world again\n",
      "again and hello makes perfect practice world\n"
     ]
    }
   ],
   "source": [
    "s = input().split(' ')\n",
    "print(' '.join(sorted(list(set(s)))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Question:\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\n",
    "\n",
    "Example:\n",
    "0100,0011,1010,1001\n",
    "\n",
    "Then the output should be:\n",
    "1010\n",
    "\n",
    "Notes: Assume the data is input by console."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0100,0011,1010,1001\n",
      "4\n",
      "3\n",
      "10\n",
      "9\n",
      "1010\n"
     ]
    }
   ],
   "source": [
    "bin_nums = input().split(',')\n",
    "values = []\n",
    "for bin_num in bin_nums:\n",
    "    num = int(bin_num,2)\n",
    "    print(num)\n",
    "    if not num%5:\n",
    "        values.append(bin_num)\n",
    "print(','.join(values))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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\n"
     ]
    }
   ],
   "source": [
    "nums = []\n",
    "for num in range(1000, 3001):\n",
    "    s = str(num)\n",
    "    if(int(s[0])%2==0 and int(s[1])%2==0 and int(s[2])%2==0 and int(s[3])%2==0):\n",
    "        nums.append(s)\n",
    "print(','.join(nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Write a program that accepts a sentence and calculate the number of letters and digits.\n",
    "Suppose the following input is supplied to the program:\n",
    "hello world! 123\n",
    "Then, the output should be:\n",
    "LETTERS 10\n",
    "DIGITS 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Write a program that accepts a sentence and calculate the number of letters and digits. Suppose the following input is supplied to the program: hello world! 123 Then, the output should be: LETTERS 10 DIGITS 3\n",
      "LETTERS  162\n",
      "DIGITS  6\n"
     ]
    }
   ],
   "source": [
    "def print_alphanum(sent):\n",
    "    let = 0\n",
    "    dig = 0\n",
    "    for char in sent:\n",
    "        if(char.isalpha()):\n",
    "            let += 1\n",
    "        elif(char.isdigit()):\n",
    "            dig += 1\n",
    "        else:\n",
    "            pass\n",
    "    print('LETTERS ', let)\n",
    "    print('DIGITS ', dig)\n",
    "print_alphanum(input())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that accepts a sentence and calculate the number of upper case letters and lower case letters.\n",
    "Suppose the following input is supplied to the program:\n",
    "Hello world!\n",
    "Then, the output should be:\n",
    "UPPER CASE 1\n",
    "LOWER CASE 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n",
      "UPPER CASE 1\n",
      "LOWER CASE 9\n"
     ]
    }
   ],
   "source": [
    "def print_case(sent):\n",
    "    lower = 0\n",
    "    upper = 0\n",
    "    for char in sent:\n",
    "        if(char.islower()):\n",
    "            lower += 1\n",
    "        elif(char.isalpha()):\n",
    "            upper += 1\n",
    "    print('UPPER CASE', upper)\n",
    "    print('LOWER CASE', lower)\n",
    "print_case(input())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "9\n",
    "Then, the output should be:\n",
    "11106"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "11106\n"
     ]
    }
   ],
   "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use a list comprehension to square each odd number in a list. The list is input by a sequence of comma-separated numbers.\n",
    "Suppose the following input is supplied to the program:\n",
    "1,2,3,4,5,6,7,8,9\n",
    "Then, the output should be:\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": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1,2,3,4,5,6,7,8,9\n",
      "[1, '2', 9, '4', 25, '6', 49, '8', 81]\n"
     ]
    }
   ],
   "source": [
    "def list_squared(nums):\n",
    "    print([int(x)*int(x) if int(x)%2 == 1 else x for x in nums])\n",
    "list_squared(input().split(','))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "```\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",
    "D 100\n",
    "W 200\n",
    "\n",
    "D means deposit while W means withdrawal.\n",
    "Suppose the following input is supplied to the program:\n",
    "D 300\n",
    "D 300\n",
    "W 200\n",
    "D 100\n",
    "Then, the output should be:\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.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D 500\n",
      "W 300\n",
      "\n",
      "200\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "result = 0\n",
    "while True:\n",
    "    s = input()\n",
    "    if not s:\n",
    "        break\n",
    "    values = s.split(' ')\n",
    "    if values[0] == 'W':\n",
    "        result -= int(values[1])\n",
    "    elif values[0] == 'D':\n",
    "        result += int(values[1])\n",
    "    else:\n",
    "        pass\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\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",
    "Example\n",
    "If the following passwords are given as input to the program:\n",
    "ABd1234@1,a F1#,2w3E*,2We3345\n",
    "Then, the output of the program should be:\n",
    "ABd1234@1\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABd1234@1,a F1#,2w3E*,2We3345\n",
      "ABd1234@1\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "valid_pwds = []\n",
    "items = [x for x in input().split(',')]\n",
    "for item in items:\n",
    "    if 6 > len(item) or len(item) > 12:\n",
    "        continue\n",
    "    else:\n",
    "        pass\n",
    "    if not re.search(\"[a-z]\", item):\n",
    "        continue\n",
    "    elif not re.search(\"[0-9]\", item):\n",
    "        continue\n",
    "    elif not re.search(\"[A-Z]\", item):\n",
    "        continue\n",
    "    elif not re.search(\"[$#@]\", item):\n",
    "        continue\n",
    "    elif re.search(\"\\s\", item):\n",
    "        continue\n",
    "    else:\n",
    "        pass\n",
    "    valid_pwds.append(item)\n",
    "print(\",\".join(valid_pwds))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\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",
    "1: Sort based on name;\n",
    "2: Then sort based on age;\n",
    "3: Then sort by score.\n",
    "The priority is that name > age > score.\n",
    "If the following tuples are given as input to the program:\n",
    "Tom,19,80\n",
    "John,20,90\n",
    "Jony,17,91\n",
    "Jony,17,93\n",
    "Json,21,85\n",
    "Then, the output of the program should be:\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": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "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"
     ]
    }
   ],
   "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)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Define a class with a generator which can iterate the numbers, which are divisible by 7, between a given range 0 and n.```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "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"
     ]
    }
   ],
   "source": [
    "def put_nums(n):\n",
    "    i = 0\n",
    "    while i<n:\n",
    "        j=i\n",
    "        i=i+1\n",
    "        if j%7==0:\n",
    "            yield j\n",
    "\n",
    "for num in put_nums(int(input())):\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\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",
    "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",
    "UP 5\n",
    "DOWN 3\n",
    "LEFT 3\n",
    "RIGHT 2\n",
    "Then, the output of the program should be:\n",
    "2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UP 3\n",
      "DOWN 3\n",
      "UP 2\n",
      "LEFT 3\n",
      "RIGHT 2\n",
      "\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "final_pos = [0,0]\n",
    "while True:\n",
    "    s = input()\n",
    "    if not s:\n",
    "        break\n",
    "    dirs, val = s.split(' ')\n",
    "    if dirs == 'UP':\n",
    "        final_pos[0] += int(val)\n",
    "    elif dirs == 'DOWN':\n",
    "        final_pos[0] -= int(val)\n",
    "    elif dirs == 'LEFT':\n",
    "        final_pos[1] -= int(val)\n",
    "    elif dirs == 'RIGHT':\n",
    "        final_pos[1] += int(val)\n",
    "    else:\n",
    "        pass\n",
    "print(int(round(math.sqrt(final_pos[1]**2 + final_pos[0]**2))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Write a program to compute the frequency of the words from the input. The output should output after sorting the key alphanumerically. \n",
    "Suppose the following input is supplied to the program:\n",
    "New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.\n",
    "Then, the output should be:\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",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "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": [
    "from collections import defaultdict\n",
    "def compute_freq(inp):\n",
    "    word_dict = defaultdict(int)\n",
    "    words = inp.split(' ')\n",
    "    for word in words:\n",
    "        word_dict[word] = word_dict.get(word,0)+1\n",
    "    keys_dict = list(word_dict.keys())\n",
    "    keys_dict.sort()\n",
    "    for k in keys_dict:\n",
    "        print(k,':',word_dict[k])\n",
    "compute_freq(input())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```Write a method which can calculate square value of number```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1024\n"
     ]
    }
   ],
   "source": [
    "def square(num):\n",
    "    return num ** 2\n",
    "print(square(32))"
   ]
  }
 ],
 "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}