Python_Exercise_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CAPABLE MACHINE #"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### website - capablemachine.com"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Author - Sarang Deshmukh\n",
    "Skilled in C, C++, Python. I have working experience across the domains of Computer Vision, Natural Language Processing with Python. I have solved data problems using Machine Learning and Deep Learning algorithms. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "If you are a very beginner with python then I hope this exercise will help you a lot to get your hands free with python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### PREREQUISITES -\n",
    "\n",
    "You must be comfortable with variables, linear equations.\n",
    "Ideally, you should have some programming experience in Object Oriented Language such as, C, C++ ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Problem statments are taken from Hackerrank, Github, Kaggle and other resources from internet. All the given solutions are in python 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Let's Start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write code to print Hello World'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print('Hello World')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''write code to print arithmatical operations'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "102\n",
      "98\n",
      "50.0\n",
      "50\n",
      "200\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "a = 100\n",
    "b = 2\n",
    "print(a+b)\n",
    "print(a-b)\n",
    "print(a/b)\n",
    "print(a//b)\n",
    "print(a*b)\n",
    "print(a%b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''write code that take input from user and print sqaure of input'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "x = int(input())\n",
    "print(x**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Sample Input\n",
    "\n",
    "6 \n",
    "Sample Output\n",
    "\n",
    "     #\n",
    "    ##\n",
    "   ###\n",
    "  ####\n",
    " #####\n",
    "######'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "     #\n",
      "    ##\n",
      "   ###\n",
      "  ####\n",
      " #####\n",
      "######\n",
      "\n"
     ]
    }
   ],
   "source": [
    "n= int(input())\n",
    "for i in range(1,n+1):\n",
    "    print(\" \"*(n-i) + \"#\"*i)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Sample Input\n",
    "\n",
    "6 \n",
    "Sample Output\n",
    "\n",
    "# # # # # # \n",
    "# # # # # # \n",
    "# # # # # # \n",
    "# # # # # # \n",
    "# # # # # # \n",
    "# # # # # # '''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "# # # # # # \n",
      "# # # # # # \n",
      "# # # # # # \n",
      "# # # # # # \n",
      "# # # # # # \n",
      "# # # # # # \n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "for i in range(n):\n",
    "    for j in range(n):\n",
    "        print(\"#\",end = \" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Print rectangle, such that width is twice of height\n",
    "Sample Input\n",
    "\n",
    "6 \n",
    "Sample Output\n",
    "\n",
    "# # # # # # # # # # # # \n",
    "# # # # # # # # # # # # \n",
    "# # # # # # # # # # # # \n",
    "# # # # # # # # # # # # \n",
    "# # # # # # # # # # # # \n",
    "# # # # # # # # # # # # \n",
    "\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "# # # # # # # # # # # # \n",
      "# # # # # # # # # # # # \n",
      "# # # # # # # # # # # # \n",
      "# # # # # # # # # # # # \n",
      "# # # # # # # # # # # # \n",
      "# # # # # # # # # # # # \n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "for i in range(n):\n",
    "    for j in range(1,n+n+1):\n",
    "        print(\"#\",end = \" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''print a rectangle of given height and width'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "5\n",
      "# # # # # \n",
      "# # # # # \n",
      "# # # # # \n",
      "# # # # # \n",
      "# # # # # \n",
      "# # # # # \n",
      "# # # # # \n",
      "# # # # # \n",
      "# # # # # \n",
      "# # # # # \n"
     ]
    }
   ],
   "source": [
    "h = int(input())\n",
    "w = int(input())\n",
    "for i in range(h):\n",
    "    for j in range(w):\n",
    "        print(\"#\",end = \" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''print the capital of the France'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Paris\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "capital = input()\n",
    "if (capital == \"Paris\"):\n",
    "    print(True)\n",
    "else:\n",
    "    print(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program to calculate sum of n natural numbers'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "sum of natural no. 6 is 21\n"
     ]
    }
   ],
   "source": [
    "#using while loop\n",
    "num = int(input())\n",
    "sum1 = 0\n",
    "hold = num\n",
    "if n<=0:\n",
    "    print('enter positive number')\n",
    "else:\n",
    "    while num > 0:\n",
    "        sum1 = sum1 + num\n",
    "        num  = num - 1;\n",
    "    print('sum of natural no.',hold,'is',sum1)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "sum of natural no. 6 is 21\n"
     ]
    }
   ],
   "source": [
    "#using for loop\n",
    "n = int(input())\n",
    "sum1 = 0\n",
    "for i in range(1, n+1):\n",
    "    if n > 0:\n",
    "        sum1 = sum1 + i\n",
    "        i = i - 1\n",
    "print('sum of natural no.',n,'is',sum1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program which will find all such numbers which are \n",
    "divisible by 7 but are not a multiple of 5, between 2000 and 3200 (both included).\n",
    "The numbers obtained should be printed in a comma-separated sequence\n",
    "on a single line.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "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,\b\n"
     ]
    }
   ],
   "source": [
    "for i in range(2000,3201):\n",
    "    if i%7 == 0 and i%5 != 0:\n",
    "        print(i,end = ',')\n",
    "print(\"\\b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a method which can calculate square value of number'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "def square(x):\n",
    "    return x**2\n",
    "print(square(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Define a function which can print a dictionary where \n",
    "the keys are numbers between 1 and 20 (both included) and the values \n",
    "are square of keys.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100, 11: 121, 12: 144, 13: 169, 14: 196, 15: 225, 16: 256, 17: 289, 18: 324, 19: 361, 20: 400}\n"
     ]
    }
   ],
   "source": [
    "def square():\n",
    "    d = dict()\n",
    "    for i in range(1,21):\n",
    "        d[i] = i**2\n",
    "    print(d)\n",
    "square()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100, 11: 121, 12: 144, 13: 169, 14: 196, 15: 225, 16: 256, 17: 289, 18: 324, 19: 361, 20: 400}\n"
     ]
    }
   ],
   "source": [
    "def square():\n",
    "    dict = {i:i**2 for i in range(1,21)}\n",
    "    print(dict)\n",
    "square()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Define a function which can generate and print a list where the values\n",
    "are square of numbers between 1 and 20 (both included).'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400]\n"
     ]
    }
   ],
   "source": [
    "def square():\n",
    "    list1 = [i**2 for i in range(1,21)]\n",
    "    print(list1)\n",
    "square()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Define a function which can generate a list where the values are \n",
    "square of numbers between 1 and 20 (both included). \n",
    "Then the function needs to print the first 5 elements in the list.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "def square():\n",
    "    list1 = [i**2 for i in range(1,21)]\n",
    "    print(list1[:5])\n",
    "square()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Define a function which can generate and print a tuple where the value are \\nsquare of numbers between 1 and 20 (both included).'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''Define a function which can generate and print a tuple where the value are \n",
    "square of numbers between 1 and 20 (both included).'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400)\n"
     ]
    }
   ],
   "source": [
    "def square():\n",
    "    list1 = [i**2 for i in range(1,21)]\n",
    "    print(tuple(list1))\n",
    "square()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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: 8 Then, the output \n",
    "should be:40320'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "40320\n"
     ]
    }
   ],
   "source": [
    "n = int(input()) #input  function for taking input\n",
    "fact = 1\n",
    "for i in range(1,n+1):\n",
    "    fact = fact*i\n",
    "print(fact)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program which can map() to make a list whose \n",
    "elements are square of elements in [1,2,3,4,5,6,7,8,9,10].'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3,4,5,6,7,8,9,10]\n",
    "output = map(lambda x:x**2 ,lst)\n",
    "print(list(output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program which can filter() to make a list whose\n",
    "elements are even number between 1 and 20 (both included).'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n"
     ]
    }
   ],
   "source": [
    "def even(x):\n",
    "    return x%2 == 0\n",
    "output = filter(even,range(1,21))\n",
    "print(list(output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''With a given integral number n, write a program to generate a dictionary\n",
    "that contains (i, i x i) such that is an integral number between 1 and n\n",
    "(both included). and then the program should print the dictionary.Suppose \n",
    "the following input is supplied to the program: 8 \n",
    "Then, the output should be:\n",
    "\n",
    "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}\n"
     ]
    }
   ],
   "source": [
    "#Method 1\n",
    "n = int(input())\n",
    "output = {}\n",
    "for i in range(1,n+1):\n",
    "    output[i] = i*i\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}\n"
     ]
    }
   ],
   "source": [
    "#Method 2\n",
    "n = int(input())\n",
    "output = {i : i*i for i in range(1,n+1)}\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program which accepts a sequence of comma-separated numbers from \n",
    "console and generate a list and a tuple which contains every number.Suppose \n",
    "the following input is supplied to the program:\n",
    "34,67,55,33,12,98\n",
    "\n",
    "Then, the output should be:\n",
    "\n",
    "['34', '67', '55', '33', '12', '98']\n",
    "('34', '67', '55', '33', '12', '98')'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "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": [
    "lst = input().split(',')\n",
    "tpl = tuple(lst)\n",
    "print(lst)\n",
    "print(tpl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Use a list comprehension to square each odd number in a list. \n",
    "The list is input by a sequence of comma-separated numbers. \n",
    ">Suppose the following input is supplied to the program:'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1,2,3,4,5\n",
      "1,9,25\n"
     ]
    }
   ],
   "source": [
    "lst = [str(int(i)**2) for i in input().split(\",\") if int(i)%2]\n",
    "print(\",\".join(lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''You are required to write a program to sort the (name, age, score) \n",
    "tuples by ascending order where name is string, age and score are numbers. \n",
    "The tuples are input by console. The sort criteria is:\n",
    "\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.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tom,19,80\n",
      "john,20,80\n",
      "sarang,22,100\n",
      "jony,17,93\n",
      "json,21,45\n",
      "\n",
      "[('john', '20', '80'), ('jony', '17', '93'), ('json', '21', '45'), ('sarang', '22', '100'), ('tom', '19', '80')]\n"
     ]
    }
   ],
   "source": [
    "lst = []\n",
    "while True:\n",
    "    s = input().split(',')\n",
    "    if not s[0]:                          # breaks for blank input\n",
    "        break\n",
    "    lst.append(tuple(s))\n",
    "\n",
    "lst.sort(key= lambda x:(x[0],x[1],x[2]))  # here key is defined by lambda and the data is sorted by element priority 0>1>2 in accending order\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Define a class named American and its subclass NewYorker.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.American object at 0x0000022F512F7E88>\n",
      "<__main__.NewYorker object at 0x0000022F512F7248>\n"
     ]
    }
   ],
   "source": [
    "class American():\n",
    "    pass\n",
    "\n",
    "class NewYorker(American):\n",
    "    pass\n",
    "\n",
    "american = American()\n",
    "newyorker = NewYorker()\n",
    "\n",
    "print(american)\n",
    "print(newyorker)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Define a class with a generator which can iterate the numbers, \n",
    "which are divisible by 7, between a given range 0 and n.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter no...49\n",
      "7\n",
      "14\n",
      "21\n",
      "28\n",
      "35\n",
      "42\n",
      "49\n"
     ]
    }
   ],
   "source": [
    "class Division():\n",
    "    def seven(self,n):\n",
    "        for i in range(0,n+1):\n",
    "            if i%7==0: yield i\n",
    "        \n",
    "for i in Division().seven(int(input('enter no...'))):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Define a class which has at least two methods:\n",
    "\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": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love India\n",
      "I LOVE INDIA\n"
     ]
    }
   ],
   "source": [
    "class IOstring():\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    def get_string(self):\n",
    "        self.s = input()\n",
    "    def print_string(self):\n",
    "        print(self.s.upper())\n",
    "xx = IOstring()\n",
    "xx.get_string()\n",
    "xx.print_string()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Define a class Person and its two child classes: Male and Female. \n",
    "All classes have a method \"getGender\" which can print \"Male\" for \n",
    "Male class and \"Female\" for Female class.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "male\n",
      "female\n"
     ]
    }
   ],
   "source": [
    "class Person(object):\n",
    "    def getgender(self):\n",
    "        return \"unknown\"\n",
    "class male(Person):\n",
    "    def getgender(self):\n",
    "        return \"male\"\n",
    "class female(Person):\n",
    "    def getgender(self):\n",
    "        return \"female\"\n",
    "amale = male()\n",
    "afemale = female()\n",
    "print(amale.getgender())\n",
    "print(afemale.getgender())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''_Write a program which takes 2 digits, X,Y as input and generates a \n",
    "2-dimensional array. The element value in the i-th row and j-th column of\n",
    "the array should be i _ j.*\n",
    "\n",
    "Note: i=0,1.., X-1; j=0,1,¡­Y-1. Suppose the following inputs are given\n",
    "to the program: 3,5\n",
    "\n",
    "Then, the output of the program should be:\n",
    "\n",
    "[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3,5\n",
      "[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]\n"
     ]
    }
   ],
   "source": [
    "x, y = map(int,input().split(','))\n",
    "output = [[i*j for j in range(y)] for i in range(x)]\n",
    "print(output) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Please write a program using generator to print the even numbers \n",
    "between 0 and n in comma separated form while n is input by console.\n",
    "\n",
    "Example: If the following n is given as input to the program:\n",
    "\n",
    "10\n",
    "Then, the output of the program should be:\n",
    "\n",
    "0,2,4,6,8,10'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "0,2,4,6,8,10,"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "for i in range(0,n+1):\n",
    "    if i%2==0:\n",
    "        print(i,end = ',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Please write a program using generator to print the numbers which \n",
    "can be divisible by 5 and 7 between 0 and n in comma separated form while n \n",
    "is input by console.\n",
    "\n",
    "Example: If the following n is given as input to the program:\n",
    "\n",
    "100\n",
    "Then, the output of the program should be:\n",
    "\n",
    "0,35,70'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "0,35,70,"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "for i in range(0,n+1):\n",
    "    if i%5==0 and i%7 == 0:\n",
    "        print(i,end = ',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Please write assert statements to verify \n",
    "that every number in the list [2,4,6,8] is even.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [2,4,6]\n",
    "for i in data:\n",
    "    assert i%2 == 0, \"{} is not an even number\".format(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Please write a program to print the list after removing \n",
    "even numbers in [5,6,77,45,22,12,24].\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 77, 45]\n"
     ]
    }
   ],
   "source": [
    "li = [5,6,77,45,22,12,24]\n",
    "li = [x for x in li if x%2!=0]\n",
    "print(li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program that accepts a comma separated sequence of words as input\n",
    "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",
    "Then, the output should be:\n",
    "\n",
    "bag,hello,without,world'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "without,hello,bag,world\n",
      "bag hello without world\n"
     ]
    }
   ],
   "source": [
    "lst = input().split(',')\n",
    "lst.sort()\n",
    "print(\" \".join(lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program that accepts a sequence of whitespace separated words \n",
    "as input and prints the words after removing all duplicate words and sorting \n",
    "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",
    "Then, the output should be:\n",
    "\n",
    "again and hello makes perfect practice world'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "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": [
    "word = input().split()\n",
    "for i in word:\n",
    "        if word.count(i) > 1:\n",
    "            word.remove(i)\n",
    "word.sort()\n",
    "print(' '.join(word))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Define a function that can accept two strings as input and\n",
    "print the string with maximum length in console. If two strings have \n",
    "the same length, then the function should print all strings line by line.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "tataa\n",
      "['hello']\n",
      "['tataa']\n"
     ]
    }
   ],
   "source": [
    "s1 = input().split()\n",
    "s2 = input().split()\n",
    "def both(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",
    "both(s1,s2)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program to read an ASCII string and to convert \n",
    "it to a unicode string encoded by utf-8.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n",
      "b'hello world'\n"
     ]
    }
   ],
   "source": [
    "s = input()\n",
    "u = s.encode('utf-8')\n",
    "print(u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program to compute 1/2+2/3+3/4+...+n/n+1 with a given \n",
    "n input by console (n>0).\n",
    "\n",
    "Example: If the following n is given as input to the program:\n",
    "\n",
    "5\n",
    "Then, the output of the program should be:\n",
    "\n",
    "3.55\n",
    "In case of input data being supplied to the question, \n",
    "it should be assumed to be a console input.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "3.5500000000000003\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "sum = 0\n",
    "for i in range(1,n+1):\n",
    "    sum += float(float((i)/(i+1)))\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program which accepts a sequence of comma separated 4 \n",
    "digit binary numbers as its input and then check whether they are divisible\n",
    "by 5 or not. The numbers that are divisible by 5 are to be printed in a comma \n",
    "separated sequence.\n",
    "\n",
    "Example:\n",
    "\n",
    "0100,0011,1010,1001\n",
    "Then the output should be:\n",
    "\n",
    "1010'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0100,0011,1010,1001\n",
      "1010\n"
     ]
    }
   ],
   "source": [
    "data = input().split(',')\n",
    "def check(x):\n",
    "        return int(x,2)%5 == 0\n",
    "data = list(filter(check,data))\n",
    "print(','.join(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Please write a program which accepts a string from console and print it \n",
    "in reverse order.\n",
    "\n",
    "Example: If the following string is given as input to the program:*\n",
    "\n",
    "rise to vote sir\n",
    "Then, the output of the program should be:\n",
    "\n",
    "ris etov ot esir'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rise to vote sir\n",
      "ris etov ot esir\n"
     ]
    }
   ],
   "source": [
    "s= input()\n",
    "s = s[::-1]\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Please write a program which accepts a string from console and print \n",
    "the characters that have even indexes.\n",
    "\n",
    "Example: If the following string is given as input to the program:\n",
    "\n",
    "H1e2l3l4o5w6o7r8l9d\n",
    "Then, the output of the program should be:\n",
    "\n",
    "Helloworld'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H1e2l3l4o5w6o7r8l9d\n",
      "Helloworld\n"
     ]
    }
   ],
   "source": [
    "s = input()\n",
    "s = s[::2]\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H1e2l3l4o5w6o7r8l9d\n",
      "Helloworld\n"
     ]
    }
   ],
   "source": [
    "#or\n",
    "s = input()\n",
    "x = ''\n",
    "for i in range(len(s)):\n",
    "    if i%2==0:\n",
    "        x += s[i]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program that accepts a sentence and calculate the number of \n",
    "upper case letters and lower case letters.\n",
    "\n",
    "Suppose the following input is supplied to the program:\n",
    "\n",
    "Hello world!\n",
    "Then, the output should be:\n",
    "\n",
    "UPPER CASE 1\n",
    "LOWER CASE 9'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n",
      "1\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "word = input()\n",
    "upper = 0\n",
    "lower = 0\n",
    "for i in word:\n",
    "    if i.isupper() == True:\n",
    "        upper += 1\n",
    "    if i.islower() == True:\n",
    "        lower += 1\n",
    "print(upper)\n",
    "print(lower)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program that computes the value of a+aa+aaa+aaaa with a given digit as the value of a.\n",
    "\n",
    "Suppose the following input is supplied to the program:\n",
    "\n",
    "9\n",
    "Then, the output should be:\n",
    "\n",
    "11106'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "11106\n"
     ]
    }
   ],
   "source": [
    "a = input()\n",
    "total = int(a) + int(2*a) + int(3*a) + int(4*a)\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''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",
    "Then, the output should be:\n",
    "\n",
    "LETTERS 10\n",
    "DIGITS 3'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world! 123\n",
      "LETTERS 10\n",
      "DIGITS 3\n"
     ]
    }
   ],
   "source": [
    "word = input()\n",
    "letter, digits = 0,0\n",
    "\n",
    "for i in word:\n",
    "    if i.isalpha(): # returns True if alphabet\n",
    "        letter += 1\n",
    "    elif i.isnumeric(): # returns True if numeric\n",
    "        digits += 1\n",
    "print(f\"LETTERS {letter}\\nDIGITS {digits}\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''You are given a string and your task is to swap cases. In other words, \n",
    "convert all lowercase letters to uppercase letters and vice versa.\n",
    "\n",
    "For Example:\n",
    "\n",
    "Www.HackerRank.com → wWW.hACKERrANK.COM\n",
    "Pythonist 2 → pYTHONIST 2'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Www.HackerRank.com\n",
      "wWW.hACKERrANK.COM\n"
     ]
    }
   ],
   "source": [
    "def swap_case(s):\n",
    "    a = \"\"\n",
    "    for letter in s:\n",
    "        if letter.isupper() == True:\n",
    "            a+=(letter.lower())\n",
    "        else:\n",
    "            a+=(letter.upper())\n",
    "    return a\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    s = input()\n",
    "    result = swap_case(s)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''In this challenge, the user enters a string and a substring. \n",
    "You have to print the number of times that the substring occurs in the \n",
    "given string. String traversal will take place from left to right, \n",
    "not from right to left.\n",
    "Sample Input\n",
    "\n",
    "ABCDCDC\n",
    "CDC\n",
    "Sample Output\n",
    "\n",
    "2'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "asdasdfg\n",
      "asd\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "string = input().strip()\n",
    "sub_string = input().strip()\n",
    "count=0  \n",
    "idx=0    \n",
    "for i in range(len(string)):\n",
    "    if len(string)>len(sub_string):             \n",
    "        idx=string.find(sub_string)            \n",
    "        if (idx>=0):\n",
    "            count += 1\n",
    "        string=string[(idx+1):]\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''You are given a string .\n",
    "Your task is to find out if the string  contains: alphanumeric\n",
    "characters, alphabetical characters, digits, lowercase \n",
    "and uppercase characters.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sdfg23\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "str = input()\n",
    "print(any(c.isalnum()  for c in str))\n",
    "print(any(c.isalpha() for c in str))\n",
    "print(any(c.isdigit() for c in str))\n",
    "print(any(c.islower() for c in str))\n",
    "print(any(c.isupper() for c in str))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Read a given string, change the character at a given index and then print the\n",
    "modified string.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "asdfg\n",
      "2 e\n",
      "asefg\n"
     ]
    }
   ],
   "source": [
    "s = input()\n",
    "i, c = input().split()\n",
    "def mutate_string(string, position, character):\n",
    "    list1 = list(string)\n",
    "    list1[position] = character\n",
    "    return ''.join(list1)\n",
    "s_new = mutate_string(s,int(i),c)\n",
    "print(s_new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''You are given a string  and width .\n",
    "Your task is to wrap the string into a paragraph of width .'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "helloworld\n",
      "2\n",
      "he ll ow or ld\n"
     ]
    }
   ],
   "source": [
    "import textwrap\n",
    "string = input()\n",
    "max_width = int(input())\n",
    "print(' '.join(textwrap.wrap(string,max_width))) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Given an array, , of  integers and an array, , representing the respective \n",
    "weights of 's elements, calculate and print the weighted mean of 's elements. \n",
    "Your answer should be rounded to a scale of 1 decimal place \n",
    "Sample Input\n",
    "\n",
    "5\n",
    "10 40 30 50 20\n",
    "1 2 3 4 5\n",
    "Sample Output\n",
    "\n",
    "32.0\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "12 13\n",
      "1 2\n",
      "12.7\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "s = 0\n",
    "a = list(map(int,input().split()))\n",
    "b = list(map(int,input().split()))\n",
    "for i in range(n): \n",
    "    s += a[i] * b[i]\n",
    "print(round(s/sum(b),1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Given an integer,n , print the following values for each integer i from 1 to n:\n",
    "\n",
    "Decimal\n",
    "Octal\n",
    "Hexadecimal (capitalized)\n",
    "Binary\n",
    "The four values must be printed on a single line in the order specified above \n",
    "for each i from 1 to n.Each value should be space-padded to match the width \n",
    "of the binary value of m.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n",
      "    1     1     1     1\n",
      "    2     2     2    10\n",
      "    3     3     3    11\n",
      "    4     4     4   100\n",
      "    5     5     5   101\n",
      "    6     6     6   110\n",
      "    7     7     7   111\n",
      "    8    10     8  1000\n",
      "    9    11     9  1001\n",
      "   10    12     A  1010\n",
      "   11    13     B  1011\n",
      "   12    14     C  1100\n",
      "   13    15     D  1101\n",
      "   14    16     E  1110\n",
      "   15    17     F  1111\n",
      "   16    20    10 10000\n",
      "   17    21    11 10001\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "width = len(\"{0:b}\".format(n))\n",
    "for i in range(1,n+1):\n",
    "    print(\"{0:{width}d} {0:{width}o} {0:{width}X} {0:{width}b}\".format(i,width=width))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''You are asked to ensure that the first and last names of people\n",
    "begin with a capital letter in their passports. For example, alison heck should\n",
    "be capitalised correctly as Alison Heck.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sarang deshmukh\n",
      "Sarang Deshmukh\n"
     ]
    }
   ],
   "source": [
    "s = input()\n",
    "for x in s.split():\n",
    "    s = s.replace(x,x.capitalize()) #capitalize method convert first letter to uppercase\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"EXAMPLE OF  SETS\"\n",
    "'''Now, let's use our knowledge of sets and help Mickey.\n",
    "\n",
    "Ms. Gabriel Williams is a botany professor at District College.\n",
    "One day, she asked her student Mickey to compute the average of all the\n",
    "plants with distinct heights in her greenhouse.\n",
    "\n",
    "'''\n",
    "\"WHAT IS SETS\"\n",
    "''''A set is an unordered collection of elements without duplicate entries.\n",
    "When printed, iterated or converted into a sequence, its elements will appear \n",
    "in an arbitrary order.'''\n",
    "\n",
    "'''>>> print set()\n",
    "set([])\n",
    "\n",
    ">>> print set('HackerRank')\n",
    "set(['a', 'c', 'e', 'H', 'k', 'n', 'r', 'R'])\n",
    "\n",
    ">>> print set([1,2,1,2,3,4,5,6,0,9,12,22,3])\n",
    "set([0, 1, 2, 3, 4, 5, 6, 9, 12, 22])\n",
    "\n",
    ">>> print set((1,2,3,4,5,5))\n",
    "set([1, 2, 3, 4, 5])\n",
    "\n",
    ">>> print set(set(['H','a','c','k','e','r','r','a','n','k']))\n",
    "set(['a', 'c', 'r', 'e', 'H', 'k', 'n'])\n",
    "\n",
    ">>> print set({'Hacker' : 'DOSHI', 'Rank' : 616 })\n",
    "set(['Hacker', 'Rank'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23 45 67 24\n",
      "39.75\n"
     ]
    }
   ],
   "source": [
    "arr = list(map(int,input().split()))\n",
    "s = sum(set(arr))/len(set(arr))\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''You are given two sets, A and B.\n",
    "Your job is to find whether set A is a subset of set B .\n",
    "\n",
    "If set A  is subset of set B, print True.\n",
    "If set A is not a subset of set B , print False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6\n",
      "1 2 3 4 5  6 7 8 9\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = set(input().split())\n",
    "b = set(input().split())\n",
    "print(a.issubset(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''You are given a set A and n other sets.\n",
    "Your job is to find whether set A is a strict superset of each of the N sets.\n",
    "\n",
    "Print True, if A is a strict superset of each of the N sets. Otherwise, print False.\n",
    "\n",
    "A strict superset has at least one element that does not exist in its subset.\n",
    "\n",
    "Input Format\n",
    "\n",
    "The first line contains the space separated elements of set A.\n",
    "The second line contains integer n , the number of other sets.\n",
    "The next n lines contains the space separated elements of the other sets.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n",
      "2 \n",
      "1 2\n",
      "1 4\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "A = set(input().split())\n",
    "\n",
    "for i in range(int(input())):\n",
    "    if not A.issuperset(set(input().split())):\n",
    "        print(False)\n",
    "        break\n",
    "else:\n",
    "    print(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''With two given lists [1,3,6,78,35,55] and [12,24,35,24,88,120,155], \n",
    "write a program to make a list whose elements are intersection of the above \n",
    "given lists.\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{35}\n"
     ]
    }
   ],
   "source": [
    "list1 = [1,3,6,78,35,55]\n",
    "list2 = [12,24,35,24,88,120,155]\n",
    "x = set(list1)\n",
    "y = set(list2)\n",
    "print(set.intersection(x,y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''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",
    "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'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "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. Then, the output should be:\n",
      "2:2\n",
      "3.:1\n",
      "3?:1\n",
      "New:1\n",
      "Python:5\n",
      "Read:1\n",
      "Then,:1\n",
      "and:1\n",
      "be::1\n",
      "between:1\n",
      "choosing:1\n",
      "or:2\n",
      "output:1\n",
      "should:1\n",
      "the:1\n",
      "to:1\n"
     ]
    }
   ],
   "source": [
    "ss = input().split()\n",
    "word = sorted(set(ss))\n",
    "for i in word:\n",
    "    print(\"{0}:{1}\".format(i,ss.count(i)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''You are given n words. Some words may repeat. For each word, \n",
    "output its number of occurrences. The output order should correspond with\n",
    "the input order of appearance of the word. See the sample input/output for \n",
    "clarification.\n",
    "\n",
    "Input Format\n",
    "\n",
    "The first line contains the integer,n .\n",
    "The next n  lines each contain a word.\n",
    "\n",
    "Output Format\n",
    "\n",
    "Output 2  lines.\n",
    "On the first line, output the number of distinct words from the input.\n",
    "On the second line, output the number of occurrences for each distinct word\n",
    "according to their appearance in the input.\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 \n",
      "sarang\n",
      "sarang\n",
      "deshmukh\n",
      "hello\n",
      "3\n",
      "dict_values([2, 1, 1])\n"
     ]
    }
   ],
   "source": [
    " from collections import Counter   \n",
    " A = [input() for i in range(int(input()))]   \n",
    " print(len(Counter(A)))  \n",
    " print(Counter(A).values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Given an array,X , of n integers, calculate the respective first quartile (Q1), \n",
    "second quartile (Q2), and third quartile (Q3). It is guaranteed that Q1,Q2 ,Q3 \n",
    "and  are integers.\n",
    "\n",
    "INPUT FORMAT\n",
    "The first line contains an integer,n , denoting the number of elements in the array.\n",
    "The second line contains n space-separated integers describing the array's elements.\n",
    "\n",
    "OUTPUT FORMAT\n",
    "Print  lines of output in the following order:\n",
    "\n",
    "The first line should be the value of Q1 .\n",
    "The second line should be the value of Q2 .\n",
    "The third line should be the value of Q3 .\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "3 7 8 5 12 14 21 13 18\n",
      "6\n",
      "12\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "x = sorted(list(map(int, input().split())))\n",
    "from statistics import median\n",
    "print(int(median(x[:n//2])))\n",
    "print(int(median(x)))\n",
    "print(int(median(x[(n+1)//2:])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''The interquartile range of an array is the difference between its first (Q1) \n",
    "and third (Q3) quartiles (i.e., Q1-Q3).Given an array,X, of n integers and an \n",
    "array,F , representing the respective frequencies of x's elements, construct a data \n",
    "set, S, where each x1 occurs at frequency f1. Then calculate and print S's \n",
    "interquartile range, rounded to a scale of 1  decimal place\n",
    "\n",
    "Input Format\n",
    "\n",
    "The first line contains an integer,n , denoting the number of elements \n",
    "in arrays X and F.\n",
    "The second line contains n space-separated integers describing the \n",
    "respective elements of array X.\n",
    "The third line contains n space-separated integers describing the \n",
    "respective elements of array F.\n",
    "\n",
    "Output Format\n",
    "\n",
    "Print the interquartile range for the expanded data set on a new line. \n",
    "Round your answer to a scale of 1  decimal place \n",
    "\n",
    "\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "6 12 8 10 20 16\n",
      "5 4 3 2 1 5\n",
      "9.0\n"
     ]
    }
   ],
   "source": [
    "import statistics as st\n",
    "\n",
    "n = int(input())\n",
    "X = [float(i) for i in input().split()]\n",
    "F = [int(i) for i in input().split()]\n",
    "S = []\n",
    "\n",
    "for i in range(n):\n",
    "    for f in range(F[i]):\n",
    "        S.append(X[i])\n",
    "\n",
    "S.sort()\n",
    "\n",
    "m = len(S)//2 \n",
    "\n",
    "L_half = S[:m]\n",
    "U_half = S[-m:]\n",
    "\n",
    "q1 = st.median(L_half)\n",
    "q3 = st.median(U_half)\n",
    "\n",
    "print(q3-q1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''In this challenge, we practice calculating standard deviation.\n",
    "\n",
    "Input Format\n",
    "\n",
    "The first line contains an integer, , denoting the number of elements in the array.\n",
    "The second line contains  space-separated integers describing the respective elements \n",
    "of the array.\n",
    "\n",
    "Output Format\n",
    "\n",
    "Print the standard deviation on a new line, rounded to a scale of 1 decimal place\n",
    "\n",
    "\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 \n",
      "10 20 30 40 45\n",
      "12.8\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "N = int(input())\n",
    "X = list(map(int, input().split())) # or X = np.array(input().split(), int)\n",
    "\n",
    "print(\"{0:.1f}\".format(np.std(X)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''You are given a string S. Suppose a character 'c' occurs consecutively X\n",
    "times in the string. Replace these consecutive occurrences of the \n",
    "character 'c' with (X,c) in the string.\n",
    "For a better understanding of the problem, check the explanation.\n",
    "\n",
    "Input Format\n",
    "\n",
    "A single line of input consisting of the string .\n",
    "\n",
    "Output Format\n",
    "\n",
    "A single line of output consisting of the modified string.\n",
    "\n",
    "Sample Input\n",
    "\n",
    "1222311\n",
    "\n",
    "Sample Output\n",
    "\n",
    "(1, 1) (3, 2) (1, 3) (2, 1)\n",
    "\n",
    "\n",
    "Explanation\n",
    "\n",
    "First, the character 1 occurs only once. It is replaced by(1,1) . \n",
    "Then the character 2 occurs three times, and it is replaced by(3,2)  and so on.\n",
    "\n",
    "Also, note the single space within each compression and between the compressions.\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1222311\n",
      "[(1, 1), (3, 2), (1, 3), (2, 1)]\n"
     ]
    }
   ],
   "source": [
    "from itertools import groupby\n",
    "print([(len(list(c)), int(k)) for k, c in groupby(input())])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Write a program to compute:\n",
    "\n",
    "f(n)=f(n-1)+100 when n>0\n",
    "and f(0)=0\n",
    "with a given n input by console (n>0).\n",
    "\n",
    "Example: If the following n is given as input to the program:\n",
    "\n",
    "5\n",
    "\n",
    "Then, the output of the program should be:\n",
    "\n",
    "500'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "500\n"
     ]
    }
   ],
   "source": [
    "def f(n):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    return f(n-1) + 100\n",
    "\n",
    "n = int(input())\n",
    "print(f(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''The Fibonacci Sequence is computed based on the following formula:\n",
    "\n",
    "f(n)=0 if n=0\n",
    "f(n)=1 if n=1\n",
    "f(n)=f(n-1)+f(n-2) if n>1\n",
    "Please write a program to compute the value of f(n) with a given n input by console.\n",
    "\n",
    "Example: If the following n is given as input to the program:\n",
    "\n",
    "7\n",
    "\n",
    "Then, the output of the program should be:\n",
    "\n",
    "13'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "def f(n):\n",
    "    if n < 2:\n",
    "        return n\n",
    "    return f(n-1)+f(n-2)\n",
    "n = int(input())\n",
    "print(f(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "def f(n):\n",
    "    if n == 0: \n",
    "        return 0\n",
    "    elif n == 1: \n",
    "        return 1\n",
    "    else: \n",
    "        return f(n-1)+f(n-2)\n",
    "\n",
    "n=int(input())\n",
    "print(f(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''The Fibonacci Sequence is computed based on the following formula:\n",
    "\n",
    "f(n)=0 if n=0\n",
    "f(n)=1 if n=1\n",
    "f(n)=f(n-1)+f(n-2) if n>1\n",
    "Please write a program to compute the value of f(n) with a given n input by console.\n",
    "\n",
    "Example: If the following n is given as input to the program:\n",
    "\n",
    "7\n",
    "Then, the output of the program should be:\n",
    "\n",
    "0,1,1,2,3,5,8,13'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "['0', '1', '1', '2', '3', '5', '8', '13']\n"
     ]
    }
   ],
   "source": [
    "def f(n):\n",
    "    if n < 2:\n",
    "        return n\n",
    "    return f(n-1)+f(n-2)\n",
    "n = int(input())\n",
    "value = [str(f(x)) for x in range(0,n+1)]\n",
    "print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Please write a program which count and print the numbers of each \n",
    "character in a string input by console.\n",
    "\n",
    "Example: If the following string is given as input to the program:\n",
    "\n",
    "abcdefgabc\n",
    "Then, the output of the program should be:\n",
    "\n",
    "a,2\n",
    "c,2\n",
    "b,2\n",
    "e,1\n",
    "d,1\n",
    "g,1\n",
    "f,1'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcdefgabc\n",
      "a,2\n",
      "b,2\n",
      "c,2\n",
      "d,1\n",
      "e,1\n",
      "f,1\n",
      "g,1\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "s = input()\n",
    "for letter in string.ascii_lowercase:\n",
    "    cnt = s.count(letter)\n",
    "    if cnt > 0:\n",
    "        print(\"{},{}\".format(letter,cnt))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Given the participants' score sheet for your University Sports Day, \n",
    "you are required to find the runner-up score. You are given scores. Store \n",
    "them in a list and find the score of the runner-up.\n",
    "\n",
    "If the following string is given as input to the program:\n",
    "\n",
    "5\n",
    "2 3 6 6 5\n",
    "Then, the output of the program should be:\n",
    "\n",
    "5'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "2 3 6 6 5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = map(int,input().split())\n",
    "list1 = list(set(b))\n",
    "list1.sort()\n",
    "print(list1[-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Given a square matrix, calculate the absolute difference between the \n",
    "sums of its diagonals.\n",
    "\n",
    "For example, the square matrix  is shown below:\n",
    "\n",
    "1 2 3\n",
    "4 5 6\n",
    "9 8 9\n",
    "\n",
    "Sample Input\n",
    "\n",
    "3\n",
    "11 2 4\n",
    "4 5 6\n",
    "10 8 -12\n",
    "Sample Output\n",
    "\n",
    "15\n",
    "Explanation\n",
    "\n",
    "The primary diagonal is:\n",
    "\n",
    "11\n",
    "   5\n",
    "     -12\n",
    "Sum across the primary diagonal: 11 + 5 - 12 = 4\n",
    "\n",
    "The secondary diagonal is:\n",
    "\n",
    "     4\n",
    "   5\n",
    "10\n",
    "Sum across the secondary diagonal: 4 + 5 + 10 = 19\n",
    "Difference: |4 - 19| = 15\n",
    "\n",
    "Note: |x| is the absolute value of x\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "11 2 4\n",
      "4 5 6\n",
      "10 8 -12\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "n = int(input().strip())\n",
    "arr = []\n",
    "for _ in range(n):\n",
    "    arr.append(list(map(int, input().rstrip().split())))\n",
    "sum1 = 0\n",
    "sum2 = 0\n",
    "for i in range(n):\n",
    "    sum1 += int(arr[i][i])\n",
    "    sum2 += int(arr[i][n-i-1])\n",
    "print(abs(sum1 - sum2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Write a Person class with an instance variable,age, and a constructor \\nthat takes an integer,initial age , as a parameter. The constructor must assign \\ninitial age to age after confirming the argument passed as initial age is not negative; if a negative argument \\nis passed as initial age , the constructor should set age to 0 and print Age is not valid, setting \\nage to 0.. In addition, you must write the following instance methods:\\n\\nyearPasses() should increase the age instance variable by 1 .\\namIOld() should perform the following conditional actions:\\nIf age < 13 , print You are young..\\nIf age >=13 and age <18 , print You are a teenager..\\nOtherwise, print You are old..\\n'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''Write a Person class with an instance variable,age, and a constructor \n",
    "that takes an integer,initial age , as a parameter. The constructor must assign \n",
    "initial age to age after confirming the argument passed as initial age is not negative; if a negative argument \n",
    "is passed as initial age , the constructor should set age to 0 and print Age is not valid, setting \n",
    "age to 0.. In addition, you must write the following instance methods:\n",
    "\n",
    "yearPasses() should increase the age instance variable by 1 .\n",
    "amIOld() should perform the following conditional actions:\n",
    "If age < 13 , print You are young..\n",
    "If age >=13 and age <18 , print You are a teenager..\n",
    "Otherwise, print You are old..\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "-1\n",
      "Age is not valid, setting age to 0.\n",
      "You are young.\n",
      "You are young.\n",
      "\n",
      "10\n",
      "You are young.\n",
      "You are a teenager.\n",
      "\n",
      "16\n",
      "You are a teenager.\n",
      "You are old.\n",
      "\n",
      "18\n",
      "You are old.\n",
      "You are old.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self,initialAge):\n",
    "        # Add some more code to run some checks on initialAge\n",
    "        self.age = 0\n",
    "        if initialAge < 0:\n",
    "            print(\"Age is not valid, setting age to 0.\")\n",
    "        else:\n",
    "            initialAge = self.age\n",
    "\n",
    "    def amIOld(self):\n",
    "        # Do some computations in here and print out the correct statement to the console\n",
    "        if age < 13:\n",
    "            print(\"You are young.\")\n",
    "        elif 13 <= age < 18:\n",
    "            print(\"You are a teenager.\")\n",
    "        elif age >= 18:\n",
    "            print(\"You are old.\")\n",
    "            \n",
    "    def yearPasses(self):\n",
    "        # Increment the age of the person in here\n",
    "        global age\n",
    "        age += 1\n",
    "\n",
    "t = int(input())\n",
    "for i in range(0, t):\n",
    "    age = int(input())         \n",
    "    p = Person(age)  \n",
    "    p.amIOld()\n",
    "    for j in range(0, 3):\n",
    "        p.yearPasses()       \n",
    "    p.amIOld()\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Given five positive integers, find the minimum and maximum values \n",
    "that can be calculated by summing exactly four of the five integers. \n",
    "Then print the respective minimum and maximum values as a single line of two \n",
    "space-separated long integers.\n",
    "\n",
    "\n",
    "Sample Input\n",
    "1 2 3 4 5\n",
    "Sample Output\n",
    "10 14\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5\n",
      "10 14\n"
     ]
    }
   ],
   "source": [
    "arr = list(map(int,input().rstrip().split()))\n",
    "res = []\n",
    "tot = sum(arr)\n",
    "for i in arr:\n",
    "    res.append(tot - i)\n",
    "print(\"{} {}\".format(min(res),max(res)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''You are in charge of the cake for your niece's birthday \n",
    "and have decided the cake will have one candle for each year \n",
    "of her total age. When she blows out the candles, she’ll only be \n",
    "able to blow out the tallest ones. Your task is to find out how many \n",
    "candles she can successfully blow out.\n",
    "\n",
    "Sample Input 0\n",
    "\n",
    "4\n",
    "3 2 1 3\n",
    "\n",
    "Sample Output 0\n",
    "\n",
    "2\n",
    "\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3 2 1 3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "arr = list(map(int,input().split()))\n",
    "print(arr.count(max(arr)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Given a time in 12-hour AM/PM format, convert it to military (24-hour) time.\n",
    "\n",
    "Note: Midnight is 12:00:00AM on a 12-hour clock, and 00:00:00 on a 24-hour clock. \n",
    "Noon is 12:00:00PM on a 12-hour clock, and 12:00:00 on a 24-hour clock.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "07:05:45PM\n",
      "19:05:45\n"
     ]
    }
   ],
   "source": [
    "time = input().strip()\n",
    "h, m, s = map(int, time[:-2].split(':'))\n",
    "p = time[-2:]\n",
    "h = h % 12 + (p.upper() == 'PM') * 12\n",
    "print(('%02d:%02d:%02d') % (h, m, s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Sample Input\n",
    "\n",
    "2\n",
    "Hacker\n",
    "Rank\n",
    "\n",
    "Sample Output\n",
    "\n",
    "Hce akr\n",
    "Rn ak'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "hack\n",
      "hc ak\n",
      "rank\n",
      "rn ak\n"
     ]
    }
   ],
   "source": [
    "for i in range(int(input())):\n",
    "    s = input()\n",
    "    print(s[::2], s[1::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "\n",
    "\n",
    "Sample Input\n",
    "\n",
    "3\n",
    "sam 99912222\n",
    "tom 11122222\n",
    "harry 12299933\n",
    "sam\n",
    "edward\n",
    "harry\n",
    "Sample Output\n",
    "\n",
    "sam=99912222\n",
    "Not found\n",
    "harry=12299933'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "d = {}\n",
    "for i in range(n):\n",
    "    x = input().split()\n",
    "    d[x[0]] = x[1]\n",
    "while True:\n",
    "    try:\n",
    "        name = input()\n",
    "        if name in d:\n",
    "            print(name, \"=\", d[name], sep=\"\")\n",
    "        else : print(\"Not found\")   \n",
    "    except: break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Sample Input\n",
    "\n",
    "saveChangesInTheEditor\n",
    "\n",
    "Sample Output\n",
    "\n",
    "5\n",
    "Explanation\n",
    "\n",
    "String  contains five words:\n",
    "\n",
    "save\n",
    "Changes\n",
    "In\n",
    "The\n",
    "Editor\n",
    "Thus, we print 5 on a new line.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saveChangesInTheEditor\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "print(sum(map(str.isupper,input()))+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ------------------------ PROJECT ---------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Highly recommended after solving above exersice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Problem statement\n",
    "\n",
    "Create famous 3 missionaries 3 cannibals crossing the river game. \n",
    "Rules are as follows.\n",
    "\n",
    "\n",
    "Rules\n",
    "Number of missionaries on either side should never be less than number \n",
    "of cannibals\n",
    "Only one or 2 people can travel through boat at a time.\n",
    "You win the game when all missionaries and cannibals on the right go to \n",
    "the left side\n",
    "\n",
    "Steps to solve the problem:\n",
    "    \n",
    "Step1:-\n",
    "    \n",
    "Display number of cannibals(C) and missionaries(M) on the left and right.\n",
    "Display boat(B) on the appropriate side starting from the right.\n",
    "Initial Display :-\n",
    "    \n",
    "M = 0 C = 0 |-----B| M = 3 C = 3\n",
    "\n",
    "(You can change display according to your imagination or convinience)\n",
    "\n",
    "Step2:-\n",
    "    \n",
    "Accept number of missionaries and then number of cannibals. Example: Initially \n",
    "if 1 missionaries and 1 cannibals goes from right to left the game display will \n",
    "look like this\n",
    "\n",
    "M = 1 C = 1 |B-----| M = 2 C = 2\n",
    "\n",
    "(Keep the side of the boat in mind)\n",
    "\n",
    "Don't forget to add and subtract number of missonary on both sides accordingly\n",
    "\n",
    "Step3:-\n",
    "    \n",
    "Define Invalid moves and add conditional 'if' statements accordingly\n",
    "\n",
    "Rules\n",
    "\n",
    "Number of people in a Boat should be 1 or 2\n",
    "Number of chosen missionaries or cannibals should not be greater than \n",
    "number of available missionaries or cannibals on the given side. In above \n",
    "step one should not be able subtract 2 missionaries from left as only 1 is available.\n",
    "An additional condition for you to figure out!'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Contact on sarangdeshmukh783@gmail.com for solution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ---------------------- THANK YOU ----------------------"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}