Course1 coding questions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Coding problems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Remove the leading spaces from the string  input_str = '         This is my first code'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is my first code\n"
     ]
    }
   ],
   "source": [
    "# Reading the input as a string; ignore the following two lines\n",
    "#import ast, sys\n",
    "#input_str = sys.stdin.read()\n",
    "input_str = ' This is my first code'\n",
    "final_str = input_str.lstrip()#Type your answer here\n",
    "print(final_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Description\n",
    "## Split the string input_str = 'Kumar_Ravi_003' to the person's second name, first name and unique customer code. In this example, second_name= 'Kumar', first_name= 'Ravi', customer_code = '003'.\n",
    "\n",
    "A sample output of the input 'Kumar_Ravi_003' is:\n",
    "Ravi\n",
    "Kumar\n",
    "003"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ravi\n",
      "Kumar\n",
      "003\n"
     ]
    }
   ],
   "source": [
    "#import ast,sys\n",
    "#input_str = sys.stdin.read()\n",
    "input_str = 'Kumar_Ravi_003' \n",
    "first_name = input_str[6:10]\n",
    "second_name = input_str[0:5]\n",
    "customer_code = input_str[11:14]\n",
    "print(first_name)\n",
    "print(second_name)\n",
    "print(customer_code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List_remove_append\n",
    "Description\n",
    "Remove SPSS from input_list=['SAS', 'R', 'PYTHON', 'SPSS'] and add 'SPARK' in its place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['SAS', 'R', 'PYTHON', 'SPARK']\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "input_list = ['SAS', 'R', 'PYTHON', 'SPSS']\n",
    "#(sys.stdin.read()).split(',')\n",
    "input_list.pop()\n",
    "input_list.append('SPARK')\n",
    "print(input_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "string to list conversion\n",
    "Description\n",
    "Convert a string input_str = 'I love Data Science & Python' to a list by splitting it on ‘&’. The sample output for this string will be:\n",
    "['I love Data Science ', ' Python']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I love Data Science ', ' Python']\n"
     ]
    }
   ],
   "source": [
    "#import ast,sys\n",
    "input_str = 'I love Data Science & Python'\n",
    "output_list = input_str.split('&')\n",
    "print(output_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List to String\n",
    "Description\n",
    "Convert a list ['Pythons syntax is easy to learn', 'Pythons syntax is very clear'] to a string using ‘&’. The sample output of this string will be:\n",
    "Pythons syntax is easy to learn & Pythons syntax is very clear\n",
    "\n",
    "Note that there is a space on both sides of '&' (as usual in English sentences)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pythons syntax is easy to learn & Pythons syntax is very clear\n"
     ]
    }
   ],
   "source": [
    "#import ast,sys\n",
    "input_str =  ['Pythons syntax is easy to learn', 'Pythons syntax is very clear']\n",
    "\n",
    "string_1 = ' & '.join(input_str)\n",
    "print(string_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nested List\n",
    "Description\n",
    "Extract Python from a nested list input_list =  [['SAS','R'],['Tableau','SQL'],['Python','Java']]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n"
     ]
    }
   ],
   "source": [
    "#import ast,sys\n",
    "#input_str = sys.stdin.read()\n",
    "#input_list = ast.literal_eval(input_str)\n",
    "input_list = [['SAS','R'],['Tableau','SQL'],['Python','Java']]\n",
    "answer = input_list[2][0]\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuple\n",
    "Description\n",
    "Add the element ‘Python’ to a tuple input_tuple = ('Monty Python', 'British', 1969). Since tuples are immutable, one way to do this is to convert the tuple to a list, add the element, and convert it back to a tuple.\n",
    "\n",
    "To learn how to convert a list to a tuple, search for it on Google / Stack Overflow etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Monty Python', 'British', 1969, 'Python')\n"
     ]
    }
   ],
   "source": [
    "#import ast, sys\n",
    "#input_str = sys.stdin.read()\n",
    "#input_tuple = ast.literal_eval(input_str)\n",
    "\n",
    "l = list(('Monty Python', 'British', 1969))\n",
    "l.append('Python')\n",
    "tuple_2 = tuple(l)\n",
    "print(tuple_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dict_Error\n",
    "Description\n",
    "From a Dictionary input_dict={'Name': 'Monty', 'Profession': 'Singer' }, get the value of a key ‘Label’ which is not a part of the dictionary, in such a way that Python doesn't hit an error. If the key does not exist in the dictionary, Python should return 'NA'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NA\n"
     ]
    }
   ],
   "source": [
    "#import ast,sys\n",
    "#input_str = sys.stdin.read()\n",
    "#input_dict = ast.literal_eval(input_str)\n",
    "input_dict={'Name': 'Monty', 'Profession': 'Singer' }\n",
    "answer = input_dict.get('Label', 'NA')\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting a Value from a Dictionary.\n",
    "Description\n",
    "Extract the company headed by Tim Cook from the dictionary {'Jack Dorsey': 'Twitter', 'Tim Cook': 'Apple','Jeff Bezos': 'Amazon','Mukesh Ambani': 'RJIO'}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apple\n"
     ]
    }
   ],
   "source": [
    "#import ast,sys\n",
    "#input_str = sys.stdin.read()\n",
    "#input_dict = ast.literal_eval(input_str)\n",
    "input_dict = {'Jack Dorsey': 'Twitter', 'Tim Cook': 'Apple','Jeff Bezos': 'Amazon','Mukesh Ambani': 'RJIO'}\n",
    "name = input_dict.get('Tim Cook')\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List of Values in a Dictionary.\n",
    "Description\n",
    "Create a SORTED list of all values from the dictionary input_dict = {'Jack Dorsey' : 'Twitter' , 'Tim Cook' : 'Apple','Jeff Bezos' : 'Amazon' ,'Mukesh Ambani' : 'RJIO'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Amazon', 'Apple', 'RJIO', 'Twitter']\n"
     ]
    }
   ],
   "source": [
    "#import ast,sys\n",
    "#input_str = sys.stdin.read()\n",
    "#input_dict = ast.literal_eval(input_str)\n",
    "input_dict = {'Jack Dorsey' : 'Twitter' , 'Tim Cook' : 'Apple','Jeff Bezos' : 'Amazon' ,'Mukesh Ambani' : 'RJIO'}\n",
    "value_list = list(input_dict.values())\n",
    "print(sorted(value_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set_diff\n",
    "Description\n",
    "Find the difference, using difference and symmetric_difference, between two given lists - list1 and list2.\n",
    "\n",
    "First, convert the lists into sets and store them as set_1 and set_2. Then store the difference and symmetric difference in answer_1 and answer_2 respectively. Print both the answers as sorted lists, i.e. convert the final sets to lists, sort it and then return it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = input()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "list_1 = input_list[0]\n",
    "list_2 = input_list[1]\n",
    "\n",
    "set_1 = set(list_1)\n",
    "set_2 = set(list_2)\n",
    "answer_1 = (list(set_1.difference(set_2)))\n",
    "answer_2 = (list(set_1.symmetric_difference(set_2)))\n",
    "\n",
    "\n",
    "print(answer_1)\n",
    "print(answer_2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If-Else\n",
    "Description\n",
    "Write a code to check if the string in input_str starts with a vowel or not. Print capital YES  or NO.\n",
    "\n",
    "For example, if input_str = 'analytics' then, your output should print 'YES'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "basic\n",
      "NO\n"
     ]
    }
   ],
   "source": [
    "import ast,sys\n",
    "input_str = input()\n",
    "vowels = ['A','a','E','e','I','i','O','o','U','u']\n",
    "if input_str[0].lower() in vowels:\n",
    "    print(\"YES\")\n",
    "else:\n",
    "    print(\"NO\")\n",
    "#Write your code here\n",
    "#Use capital YES or NO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating a List Comprehension\n",
    "Description\n",
    "You are given an integer 'n' as the input. Create a list comprehension containing the squares of the integers from 1 till n^2 (including 1 and n), and print the list. \n",
    "\n",
    "For example, if the input is 4, the output should be a list as follows:\n",
    "\n",
    "[1, 4, 9, 16]\n",
    "\n",
    "The input integer 'n' is stored in the variable 'n'.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "import ast, sys\n",
    "n = int(input())\n",
    "sq_lt=[x**2 for x in range (1,n+1)]\n",
    "print(sq_lt)\n",
    "\n",
    "\n",
    "# Write your code here (remember to print the list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List Comprehensions\n",
    "Description\n",
    "Extract the words that start with a vowel from a list input_list=[wood, old, apple, big, item, euphoria] using list comprehensions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['wood', 'old', 'apple', 'big', 'item', 'euphoria']\n",
      "['old', 'apple', 'item', 'euphoria']\n"
     ]
    }
   ],
   "source": [
    "import ast,sys\n",
    "input_str = input()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "vowel= ['U','u','O','o','I','i','E','e','a','A']\n",
    "list_vowel =[word for word in input_list if word[0].lower() in vowel ]\n",
    "\n",
    "print(list_vowel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionary Comprehension\n",
    "Description\n",
    "You are given an integer input n.\n",
    "\n",
    "Write a program to generate a dictionary that contains the key-value pairs i: i**2 where ' i ' is an integer number from 1 to n (both 1 and n included). \n",
    "\n",
    "For example, if the input is n=8, the output should be a dictionary as follows:\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": [
      "5\n",
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n"
     ]
    }
   ],
   "source": [
    "import ast,sys\n",
    "n = int(input())\n",
    "\n",
    "dictionary = {n : n**2 for n in range(1,n+1)}\n",
    "print(dictionary)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function\n",
    "Description\n",
    "Create a function squared(),  which takes x and y as arguments and returns the x**y value. For e.g., if x = 2  and y = 3 , then the output is 8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "x = int(input_list[0])\n",
    "y = int(input_list[1])\n",
    "def squared(x,y):\n",
    "    z=x**y\n",
    "    return(z)\n",
    "\n",
    "\n",
    "print(squared(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "function_name  = lambda <space>  input_parameters  :  output_parameters\n",
    "\n",
    "Eg: join_by_comma = lambda x : ','.join(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambda\n",
    "Description\n",
    "Create a lambda function 'greater', which takes two arguments x and y and return x if x>y otherwise y.\n",
    "If x = 2 and y= 3, then the output should be 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "a = int(input_list[0])\n",
    "b = int(input_list[1])\n",
    "\n",
    "greater =lambda x,y : x if x>y else y\n",
    "\n",
    "print(greater(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Map Function\n",
    "Description\n",
    "Using the Map function, create a list 'cube', which consists of the cube of numbers in input_list.\n",
    "\n",
    "For e.g. if the input list is [5,6,4,8,9], the output should be [125, 216, 64, 512, 729]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "\n",
    "cube= list(map(lambda x: x**3, input_list))\n",
    "\n",
    "print(cube)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Map Function\n",
    "Description\n",
    "Using the function Map, count the number of words that start with ‘S’ in input_list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "lst=['S','s']\n",
    "\n",
    "count = sum(map(lambda x: x[0] == 'S',input_list))\n",
    "\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Map Function\n",
    "Description\n",
    "Create a list ‘name’ consisting of the combination of the first name and the second name from list 1 and 2 respectively. \n",
    "\n",
    "For e.g. if the input list is:\n",
    "[ ['Ankur', 'Avik', 'Kiran', 'Nitin'], ['Narang', 'Sarkar', 'R', 'Sareen']]\n",
    "\n",
    "the output list should be the list:\n",
    "['Ankur Narang', 'Avik Sarkar', 'Kiran R', 'Nitin Sareen']\n",
    "\n",
    "Note: Add a space between first name and last name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "first_name = input_list[0]\n",
    "last_name = input_list[1]\n",
    "join = lambda x,y: x[ : ]+' '+y[ : ]\n",
    "name = list(map(join,first_name,last_name))\n",
    "\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Filter Function\n",
    "Description\n",
    "Extract a list of numbers that are multiples of 5 from a list of integers named input_list.\n",
    "\n",
    "Note: Use the filter() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "divby5 = lambda x:  x % 5 == 0\n",
    "list_answer = list(filter(divby5,input_list))\n",
    "\n",
    "print(list_answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Filter Function\n",
    "Description\n",
    "You are given a list of strings such as input_list =  ['hdjk', 'salsap', 'sherpa'].\n",
    "\n",
    "Extract a list of names that start with an ‘s’ and end with a ‘p’ (both 's' and 'p' are lowercase) in input_list.\n",
    "\n",
    "Note: Use the filter() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "sp = list(filter(lambda x: x[0] == 's' and x[-1] == 'p',input_list))\n",
    "\n",
    "print(sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reduce Function\n",
    "Description\n",
    "Using the Reduce function, concatenate a list of words in input_list, and print the output as a string.\n",
    "If input_list = ['I','Love','Python'], the output should be the string 'I Love Python'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "from functools import reduce\n",
    "\n",
    "q= str(reduce(lambda x,y: x+' '+y,input_list))\n",
    "\n",
    "print(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reduce Function\n",
    "Description\n",
    "You are given a list of numbers such as input_list = [31, 63, 76, 89]. Find and print the largest number in input_list using the reduce() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "from functools import reduce\n",
    "\n",
    "answer = reduce(lambda x,y: x if x>y else y, input_list)\n",
    "\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Factorial\n",
    "Description\n",
    "Given a number ‘n’, output its factorial using reduce().\n",
    "Note: Make sure you handle the edge case of zero. As you know, 0! = 1\n",
    "\n",
    "P.S.: Finding the factorial without using the reduce() function might lead to deduction of marks.\n",
    "\n",
    "Examples:\n",
    "Input 1:\n",
    "1\n",
    "Output 1:\n",
    "1\n",
    "\n",
    "Input 2:\n",
    "3\n",
    "Output 2:\n",
    "6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "# Read the input as an integer\n",
    "n = int(input())\n",
    "\n",
    "# Import the reduce() function\n",
    "from functools import reduce\n",
    "x=reduce(lambda x,y: x*y,range(1,n+1))\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input as an integer\n",
    "n = int(input())\n",
    "\n",
    "# Import the reduce() function\n",
    "from functools import reduce\n",
    "\n",
    "# If n is zero, simply print 1 as this case can't be handles by reduce()\n",
    "if n==0:\n",
    "    print(1)\n",
    "\n",
    "# In all other cases, use reduce() between the range 1 and (n+1). For this range,\n",
    "# define a lambda function with x and y and keep multiplying them using reduce().\n",
    "# This way, when the code reaches the end of the range, i.e. n, the factorial\n",
    "# computation will be complete.\n",
    "else:\n",
    "    print(reduce(lambda x, y: x * y, range(1, n+1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set Operations\n",
    "Description\n",
    "In a school, there are total 20 students numbered from 1 to 20. You’re given three lists named ‘C’, ‘F’, and ‘H’, representing students who play cricket, football, and hockey, respectively. Based on this information, find out and print the following: \n",
    "Students who play all the three sports\n",
    "Students who play both cricket and football but don’t play hockey\n",
    "Students who play exactly two of the sports\n",
    "Students who don’t play any of the three sports\n",
    "Format:\n",
    "Input:\n",
    "3 lists containing numbers (ranging from 1 to 20) representing students who play cricket, football and hockey respectively.\n",
    "Output:\n",
    "4 different lists containing the students according to the constraints provided in the questions.\n",
    "\n",
    "Note: Make sure you sort the final lists (in an ascending order) that you get before printing them; otherwise your answer might not match the test-cases.\n",
    "\n",
    "Examples:\n",
    "Input 1:\n",
    "[2, 5, 9, 12, 13, 15, 16, 17, 18, 19]\n",
    "[2, 4, 5, 6, 7, 9, 13, 16, 20]\n",
    "[1, 2, 5, 9, 10, 11, 12, 13, 15, 20]\n",
    "Output 1:\n",
    "[2, 5, 9, 13]\n",
    "[16]\n",
    "[12, 15, 16, 20]\n",
    "[3, 8, 14]\n",
    "\n",
    "Explanation:\n",
    "1.Given the three sets, you can see that the students numbered '2', '5', '9', and '13' play all the three sports. \n",
    "2. The student numbered '16' plays cricket and football but doesn't play hockey. \n",
    "3. The students numbered '12' and '15' play cricket and hockey, the student numbered '16' plays cricket and football and the student numbered '20' plays football and hockey.  Hence, the students who play exactly two sports are 12, 15, 16, and 20.\n",
    "4. As you can see, the students who play none of the sports are 3, 8, and 14."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the three input lists, i.e. 'C', 'F', and 'H'.\n",
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "C = input_list[0]\n",
    "F = input_list[1]\n",
    "H = input_list[2]\n",
    "\n",
    "A = range(1,21)\n",
    "c=set(C)\n",
    "f=set(F)\n",
    "h=set(H)\n",
    "a=set(A)\n",
    "\n",
    "X= sorted(c.intersection(f,h))\n",
    "print(X)\n",
    "\n",
    "Y=sorted(c.intersection(f).difference(h))\n",
    "print(Y)\n",
    "\n",
    "cuf=(c.intersection(f))\n",
    "fuh=(f.intersection(h))\n",
    "cuh=(c.intersection(h))\n",
    "Z=sorted((cuh.union(cuf,fuh)).difference(c.intersection(f,h)))\n",
    "print(Z)\n",
    "\n",
    "Q=sorted(a.difference((c.union(f,h))))\n",
    "print(Q)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the three input lists, i.e. 'C', 'F', and 'H'.\n",
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "C = input_list[0]\n",
    "F = input_list[1]\n",
    "H = input_list[2]\n",
    "\n",
    "# Convert the given lists to sets as it is easier to perform the given operations\n",
    "# on sets\n",
    "C = set(input_list[0])\n",
    "F = set(input_list[1])\n",
    "H = set(input_list[2])\n",
    "\n",
    "# Perform an '&' operation between the three sets to find out the students who play\n",
    "# all the three sports. Finally, convert it into a list, apply the sorted() function\n",
    "# and print the resultant list.\n",
    "print(sorted(list(C & F & H)))\n",
    "\n",
    "# The following opeartion gives the students who play only Cricket and Football.\n",
    "# Note that only (C & F) also contains the students who play all the three sports\n",
    "# and hence, we need to subtract (C & F & H) from it.\n",
    "print(sorted(list((C & F) - (C & F & H))))\n",
    "\n",
    "# The students who play exactly three sports can be given by the following expression\n",
    "# (C & F) gives the students who play cricket and football, (F & H) gives the students\n",
    "# who play football and hockey, and (C & H) gives the students who play cricket and\n",
    "# hockey. Performing an 'OR' operation ('|') between the three will give the students\n",
    "# who play a minimum of two sports and finally subracting (C & F & H) will give the \n",
    "# list of students who play exactly two sports.\n",
    "print(sorted(list(((C & F) | (F & H) | (C & H)) - (C & F & H))))\n",
    "\n",
    "# As the students are numbered from 1 to 20, the whole set of students can be defined\n",
    "# by creating a set containing all the numbers from 1 to 20, using range. Finally,\n",
    "# you can subract (C | F | H), from the created set to get all the students who don't\n",
    "# play even a single sport.\n",
    "print(sorted(list(set(range(1,21)) - (C | F | H))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Swapping\n",
    "Description\n",
    "You are given two integer variables,  x and y. You have to swap the values stored in x and y.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "Two numbers x and y separated by a comma.\n",
    "\n",
    "Output:\n",
    "Print 5 lines. The first two lines will have values of variables shown before swapping, and the last two lines will have values of variables shown after swapping. The third line will be blank.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "20, 50\n",
    "\n",
    "Sample output:\n",
    "x before swapping: 20\n",
    "y before swapping: 50\n",
    "\n",
    "x after swapping: 50\n",
    "y after swapping: 20\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Take input using input()\n",
    "\n",
    "#input() takes input in form of the string\n",
    "in_string=input()\n",
    "\n",
    "#here extract the two numbers from the string\n",
    "my_list = in_string.split(',')\n",
    "x=int(my_list[0])\n",
    "y=int(my_list[1])\n",
    "\n",
    "\n",
    "#print x and y before swapping\n",
    "print('x before swapping: {0}'.format(x))\n",
    "print('y before swapping: {0}'.format(y))\n",
    "print()\n",
    "\n",
    "\n",
    "#Writing your swapping code here\n",
    "x=x+y #20+50=70\n",
    "y=x-y #70-50=20\n",
    "x=x-y #70-20= 50\n",
    "\n",
    "\n",
    "#print x and y after swapping\n",
    "print('x after swapping: {0}'.format(x))\n",
    "print('y after swapping: {0}'.format(y))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Take input using input()\n",
    "\n",
    "#input() takes input in form of the string\n",
    "in_string=input()\n",
    "\n",
    "#here extract the two numbers from the string\n",
    "\n",
    "#we know the values of our interest are separated by comma so we can use split\n",
    "mylist = in_string.split(',')\n",
    "#['12','15']\n",
    "#and now get our values \n",
    "#but they are in string so we first make them int\n",
    "x = int(mylist[0])\n",
    "y = int(mylist[1])\n",
    "\n",
    "# SAJAN'S APPROACH\n",
    "\n",
    "# #print x and y before swapping\n",
    "# print('x before swapping: {0}'.format(x))\n",
    "# print('y before swapping: {0}'.format(y))\n",
    "\n",
    "# #Writing your swapping code here\n",
    "# z = x\n",
    "# x = y\n",
    "# y = z\n",
    "# print()\n",
    "# #print x and y after swapping\n",
    "# print('x after swapping: {0}'.format(x))\n",
    "# print('y after swapping: {0}'.format(y))\n",
    "\n",
    "\n",
    "#without making a new Variable\n",
    "# print x and y before swapping\n",
    "print('x before swapping: {0}'.format(x))\n",
    "print('y before swapping: {0}'.format(y))\n",
    "#Writing your swapping code here\n",
    "x=x+y\n",
    "y=x-y\n",
    "x=x-y\n",
    "print()\n",
    "print('x after swapping: {0}'.format(x))\n",
    "print('y after swapping: {0}'.format(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even Or Odd\n",
    "Description\n",
    "Given an integer, print whether it is Even or Odd.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "An integer\n",
    "\n",
    "Output:\n",
    "'Even' or 'Odd'\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "3\n",
    "\n",
    "Sample output:\n",
    "Odd\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "6\n",
    "\n",
    "Sample output:\n",
    "Even"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Take input on your own\n",
    "num=int(input())\n",
    "\n",
    "if (num%2)==0:\n",
    "    print('Even')\n",
    "else:\n",
    "    print('Odd')\n",
    "\n",
    "#start writing your code from here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beautiful Pretty Sexy\n",
    "Description\n",
    "A number k is beautiful if it is of the form 3n+1, is pretty if it is of the form 3n+2 and is sexy if it is of form 3n.\n",
    "Given a number k, print if it is beautiful, pretty or sexy.\n",
    "\n",
    "Sample input:\n",
    "21\n",
    "\n",
    "Sample output:\n",
    "sexy\n",
    "\n",
    "Sample input:\n",
    "22\n",
    "\n",
    "Sample output:\n",
    "beautiful\n",
    "\n",
    "Sample input:\n",
    "23\n",
    "\n",
    "Sample output:\n",
    "pretty\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been taken for you\n",
    "\n",
    "num=int(input())\n",
    "\n",
    "#check if the number is beautiful, pretty or sexy\n",
    "n=(num//3)\n",
    "\n",
    "if(3*n+1==num):\n",
    "    print('beautiful')\n",
    "elif(3*n+2==num):\n",
    "    print('pretty')\n",
    "elif(3*n==num):\n",
    "    print('sexy')\n",
    "else:\n",
    "    print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been taken for you\n",
    "\n",
    "k=int(input())\n",
    "\n",
    "#check if the number is beautiful, pretty or sexy\n",
    "\n",
    "if k%3==0: #if k is of form 3n\n",
    "    print('sexy')\n",
    "elif k%3==1: #else if k is of form 3n+1\n",
    "    print('beautiful')\n",
    "elif k%3==2: #else if k is of form 3n+2\n",
    "    print('pretty')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alarm Clock\n",
    "Description\n",
    "You're trying to automate your alarm clock by writing a function for it. You're given a day of the week encoded as 1=Mon, 2=Tue, ... 6=Sat, 7=Sun, and whether you are on vacation as a boolean value (a boolean object is either True or False. Google \"booleans python\" to get a better understanding). Based on the day and whether you're on vacation, write a function that returns a time in form of a string indicating when the alarm clock should ring. \n",
    "\n",
    "When not on a vacation, on weekdays, the alarm should ring at \"7:00\" and on the weekends (Saturday and Sunday) it should ring at \"10:00\". \n",
    "\n",
    "While on a vacation, it should ring at \"10:00\" on weekdays. On vacation, it should not ring on weekends, that is, it should return \"off\".\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "The input will be a list of two elements. The first element will be an integer from 1 to 7, and the second element will be a boolean value.\n",
    "\n",
    "Output:\n",
    "The output will be a string denoting the time alarm will ring or 'off'\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[7, True]\n",
    "\n",
    "Sample output:\n",
    "off\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[3, True]\n",
    "\n",
    "Sample output:\n",
    "10:00\n",
    "\n",
    "----------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Take input here\n",
    "#we will take input using ast sys\n",
    "import ast\n",
    "input_str = input()\n",
    "\n",
    "#ast.literal_eval() will evaluate the string and make a data structure for the same\n",
    "#here the input is a list since input is in '[...]', so ast.literal_eval() will\n",
    "#make a list with the same data as passed\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "#the data or the two values in list is now changed to separate variables\n",
    "day_of_the_week = input_list[0] #first element is an integer denoting the day of the week\n",
    "is_on_vacation = input_list[1] #this is a boolean denoting if its vacation or not\n",
    "\n",
    "# write your code here\n",
    "weekend=[6,7]\n",
    "\n",
    "def alarm_time(day_of_the_week,is_on_vacation):\n",
    "    if ((day_of_the_week in weekend) & (is_on_vacation==True)):\n",
    "        return 'off'\n",
    "    elif((day_of_the_week not in weekend) & (is_on_vacation==True)):\n",
    "        return '10:00'\n",
    "    elif((day_of_the_week in weekend) & (is_on_vacation==False)):\n",
    "        return '10:00'\n",
    "    elif((day_of_the_week not in weekend) & (is_on_vacation==False)):\n",
    "        return '7:00'\n",
    "    else:\n",
    "        return ' '\n",
    "        \n",
    "\n",
    "print(alarm_time(day_of_the_week,is_on_vacation))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Take input here\n",
    "#we will take input using ast sys\n",
    "import ast\n",
    "input_str = input()\n",
    "\n",
    "#ast.literal_eval() will evaluate the string and make a data structure for the same\n",
    "#here the input is a list since input is in '[...]', so ast.literal_eval() will\n",
    "#make a list with the same data as passed\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "#the data or the two values in list is now changed to separate variables\n",
    "day_of_the_week = input_list[0] #first element is an integer denoting the day of the week\n",
    "is_on_vacation = input_list[1] #this is a boolean denoting if its vacation or not\n",
    "\n",
    "# write your code here\n",
    "\n",
    "#we will solve this using a function that returns a string\n",
    "#later we will just print the string\n",
    "\n",
    "def alarm_time(day_of_the_week, is_on_vacation):\n",
    "    weekend = [6,7] #encoding of weekend days sat and sun are 6 and 7\n",
    "    if is_on_vacation:\n",
    "        if day_of_the_week not in weekend:\n",
    "            return '10:00'\n",
    "        else: #its weekend\n",
    "            return 'off'\n",
    "    else:\n",
    "        if day_of_the_week not in weekend:\n",
    "            return '7:00'\n",
    "        else: #its weekend\n",
    "            return '10:00'\n",
    "#end of function\n",
    "\n",
    "#print the result\n",
    "print(alarm_time(day_of_the_week, is_on_vacation))\n",
    "\n",
    "\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Factorial\n",
    "Description\n",
    "Factorial is a mathematical function denoted by '!'. It is defined as\n",
    "\n",
    "n factorial = n!= 1*2*3...*(n-1)*n\n",
    "\n",
    "In this question, you have to make a function that will take an integer as input, and return the factorial of that integer if that integer is greater than or equal to zero and return -1 if the number is less than zero or negative.\n",
    "\n",
    "Note: the function doesn't return print the factorial but returns it.\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "An integer n\n",
    "\n",
    "Output:\n",
    "The function returns n! if n is greater than or equal to 0.\n",
    "0! = 1\n",
    "and the function returns -1 if the number is less than 0.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "3\n",
    "\n",
    "Sample output:\n",
    "6\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "-4\n",
    "\n",
    "Sample output:\n",
    "-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take the input here\n",
    "number=int(input())\n",
    "\n",
    "\n",
    "\n",
    "#the function definition starts here\n",
    "def factorial(n):\n",
    "    #write the funtion here that finds and RETURNS factorial of next\n",
    "    if n<0:\n",
    "        return -1\n",
    "    elif n==0:\n",
    "        return 1\n",
    "    else:\n",
    "        i=1\n",
    "        f=1\n",
    "        while i<=n:\n",
    "            f=f*i\n",
    "            i=i+1\n",
    "        return f\n",
    "            \n",
    "        \n",
    "\n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "\n",
    "#function definition ends here\n",
    "\n",
    "#do not alter the code typed below\n",
    "k=factorial(number)\n",
    "print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take the input here\n",
    "number=int(input())\n",
    "\n",
    "\n",
    "\n",
    "#the function definition starts here\n",
    "def factorial(n):\n",
    "    #write the funtion here that finds and RETURNS factorial of next\n",
    "    if n<0:\n",
    "        return -1\n",
    "    elif n==0:\n",
    "        return 1\n",
    "    else:\n",
    "        f=1\n",
    "        for i in range(1,n+1):\n",
    "            f = f*i\n",
    "        return f    \n",
    "    \n",
    "\n",
    "#function definition ends here\n",
    "\n",
    "#do not alter the code typed below\n",
    "k=factorial(number)\n",
    "print(k)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse The Digits\n",
    "Description\n",
    "You will be given a number. You have to reverse the digits of the number and print it.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A positive integer greater than zero\n",
    "\n",
    "Output:\n",
    "The number in reverse order. Check sample outputs for more details.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "345200\n",
    "\n",
    "Sample output:\n",
    "2543\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "6752343\n",
    "\n",
    "Sample output:\n",
    "3432576"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input of the number here\n",
    "str=int(input())\n",
    "\n",
    "\n",
    "#write code to reverse the number here\n",
    "def reverse(num):\n",
    "    rev=0\n",
    "    dig=0\n",
    "    while (num>0):\n",
    "        dig=num%10\n",
    "        num= int(num/10)\n",
    "        rev= rev*10+dig\n",
    "    return rev\n",
    "        \n",
    "x=reverse(str)\n",
    "print(x)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input of the number here\n",
    "n = int(input())\n",
    "\n",
    "#write code to reverse the number here\n",
    "r=0\n",
    "\n",
    "while(n>0):\n",
    "    r = r*10 + n%10\n",
    "    n = n//10\n",
    "\n",
    "print(r)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How Many Chocolates?\n",
    "Description\n",
    "Sanjay loves chocolates. He goes to a shop to buy his favourite chocolate. There he notices there is an offer going on, upon bringing 3 wrappers of the same chocolate, you will get new chocolate for free. If Sanjay has m Rupees. How many chocolates will he be able to eat if each chocolate costs c Rupees?\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "Two positive integers m and c separated by a comma. The first integer is m and the second integer is c \n",
    "\n",
    "Output:\n",
    "A single integer denoting the number of chocolates Sanjay was able to eat in total.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "15, 2\n",
    "\n",
    "Sample output:\n",
    "10\n",
    "\n",
    "Explanation:\n",
    "First, he will get 15/2=7 chocolates. He then will return 6 wrappers for 2 chocolates. And lastly, these two wrappers and the one he previously had will get him one more chocolate, making a total of 7+2+1=10 chocolates.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "3,1\n",
    "\n",
    "Sample output:\n",
    "4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "\n",
    "import ast\n",
    "input_str=input()\n",
    "\n",
    "input_list=input_list=ast.literal_eval(input_str)\n",
    "\n",
    "M=input_list[0]\n",
    "cost=input_list[1]\n",
    "\n",
    "NOC= M//cost\n",
    "WR= M//cost\n",
    "\n",
    "while (WR//3!=0):\n",
    "    NOC=NOC+ (WR//3)\n",
    "    WR=(WR//3)+(WR%3)\n",
    "print(NOC)\n",
    "\n",
    "\n",
    "#start writing your code here\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#dont forget to print the number of chocolates Sanjay can eat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "mystring = input()\n",
    "mylist = mystring.split(',')\n",
    "\n",
    "m = int(mylist[0])\n",
    "c = int(mylist[1])\n",
    "\n",
    "#start writing your code here\n",
    "\n",
    "choc = m//c\n",
    "w = m//c\n",
    "\n",
    "while w//3!=0:\n",
    "    choc = choc + w//3\n",
    "    w = w//3 + w%3\n",
    "    \n",
    "\n",
    "    \n",
    "\n",
    "\n",
    "#dont forget to print the number of chocolates Sanjay can eat\n",
    "print(choc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print The Pattern\n",
    "Description\n",
    "Printing different patterns is a very good exercise to reinforce iteration through loops and strong logic building. Here you will be given a positive integer and you will generate pattern based on that integer.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A positive integer n\n",
    "1 <= n <=20\n",
    "\n",
    "Output:\n",
    "A pattern as described by the Sample input and outputs below.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "5\n",
    "\n",
    "Sample output:\n",
    "    *\n",
    "   *_*\n",
    "  *_*_*\n",
    " *_*_*_*\n",
    "*_*_*_*_*\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "3\n",
    "\n",
    "Sample output:\n",
    "  *\n",
    " *_*\n",
    "*_*_*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#please take input here\n",
    "n=int(input())\n",
    "\n",
    "#start writing your code here\n",
    "for i in range(1,n+1):\n",
    "    for j in range(n-i):\n",
    "        print(' ',end='')\n",
    "    for k in range(i-1):\n",
    "        print('*_',end='')\n",
    "    print('*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alphabetic patterns\n",
    "Description\n",
    "Given a positive integer 'n' less than or equal to 26, you are required to print the below pattern \n",
    " \n",
    "Sample Input: 5 \n",
    " \n",
    "Sample Output : \n",
    "--------e-------- \n",
    "------e-d-e------ \n",
    "----e-d-c-d-e---- \n",
    "--e-d-c-b-c-d-e-- \n",
    "e-d-c-b-a-b-c-d-e \n",
    "--e-d-c-b-c-d-e-- \n",
    "----e-d-c-d-e---- \n",
    "------e-d-e------ \n",
    "--------e-------- \n",
    " \n",
    "Sample Input  : 3 \n",
    " \n",
    "Sample Output : \n",
    "----c---- \n",
    "--c-b-c-- \n",
    "c-b-a-b-c \n",
    "--c-b-c-- \n",
    "----c----\n",
    "\n",
    "Please note that this question was asked in a Data Scientist interview."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "--------e--------\n",
      "------e-d-e------\n",
      "----e-d-c-d-e----\n",
      "--e-d-c-b-c-d-e--\n",
      "e-d-c-b-a-b-c-d-e\n",
      "--e-d-c-b-c-d-e--\n",
      "----e-d-c-d-e----\n",
      "------e-d-e------\n",
      "--------e--------\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "n = int(input())\n",
    "\n",
    "# Write your code below\n",
    "\n",
    "pattern = []\n",
    "for i in range(n):\n",
    "    temp = []\n",
    "    for j in range(i+1):\n",
    "        temp.append(chr(96+n-j))\n",
    "    for k in reversed(range(i)):\n",
    "        temp.append(chr(96+n-k))\n",
    "    pattern.append('-'.join(temp))\n",
    "\n",
    "pattern = [i.center(4*n-3, '-') for i in pattern]\n",
    "\n",
    "for i in pattern:\n",
    "    print (i)\n",
    "for i in reversed(range(n-1)):\n",
    "    print(pattern[i])\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### n = int(input())\n",
    "\n",
    "# Write your code below\n",
    "\n",
    "#first we will print first half of the problem\n",
    "#and then run the same loops in reverse for second half \n",
    "\n",
    "#first half\n",
    "#each line is divided into 4 parts\n",
    "#first -------\n",
    "#then alphabets in descending order and '-'\n",
    "#then alphabets in ascending order and '-'\n",
    "#then again ------\n",
    "for i in range(n-1,-1,-1):\n",
    "    #first print '--'\n",
    "    for j in range(i):\n",
    "        print(end=\"--\")\n",
    "    \n",
    "    #print alphabet and '-' in reverse order\n",
    "    for j in range(n-1,i,-1):\n",
    "        print(chr(j+97),end=\"-\")\n",
    "    \n",
    "    #print alphabets in ascending order in same line and '-'\n",
    "    for j in range(i,n):\n",
    "        #if last line then dont print '-'\n",
    "        if j != n-1:\n",
    "            print(chr(j+97),end=\"-\")\n",
    "        else:\n",
    "            print(chr(j+97),end=\"\")\n",
    "    \n",
    "    #print '--' again\n",
    "    for j in range(2*i):\n",
    "        print(end=\"-\")\n",
    "    \n",
    "    #after every line go to a new line to start all over again    \n",
    "    print()\n",
    "    \n",
    "\n",
    "#note how everything remains same from previous line\n",
    "#except the iteration of i\n",
    "#in first half iteration of i was from [n-1, n-2, n-3, ... 2, 1, 0]\n",
    "#in this half iteration of i is from [1, 2, 3, n-1]\n",
    "#this means everything printed in previous line will be printed again but in reverse \n",
    "#order and without last line or where i = 0\n",
    "for i in range(1,n):\n",
    "    \n",
    "    for j in range(i):\n",
    "        print(end=\"--\")\n",
    "    for j in range(n-1,i,-1):\n",
    "        print(chr(j+97),end=\"-\")\n",
    "    for j in range(i,n):\n",
    "        if j != n-1:\n",
    "            print(chr(j+97),end=\"-\")\n",
    "        else:\n",
    "            print(chr(j+97),end=\"\")\n",
    "    for j in range(2*i):\n",
    "        print(end=\"-\")\n",
    "    \n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Armstrong number\n",
    "Description\n",
    "Any number, say n is called an Armstrong number if it is equal to the sum of its digits, where each is raised to the power of number of digits in n.\n",
    "For example:\n",
    "153=13+53+33\n",
    "\n",
    "Write Python code to determine whether an entered three digit number is an Armstrong number or not. \n",
    "Assume that the number entered will strictly be a three digit number.\n",
    "Print \"True\" if it is an Armstrong number and print \"False\" if it is not.\n",
    "Sample Input:\n",
    "153\n",
    "Sample Output:\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_str=input()\n",
    "input_list=list(input_str)\n",
    "\n",
    "p= len(input_list)\n",
    "total=0\n",
    "\n",
    "for i in range(0,p):\n",
    "    total= total + int(input_list[i])**p\n",
    "    \n",
    "if total==int(input_str):\n",
    "    print('True')\n",
    "else:\n",
    "    print('False')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "\n",
    "#we can use list comprehension and map function to get the digits of the number\n",
    "digits=list(map(int,str(n)))\n",
    "#str(n) converts the number to string, an iterable, and we then simple convert each char of the string \n",
    "#which in this case is a digit to int\n",
    "#and get a list of all the digits of n\n",
    "\n",
    "#we then use map again to find the sum of cubes of all digits stored in int\n",
    "#if this is same as n, then armstrong number else not\n",
    "num=sum(list(map(lambda x:x**3,digits)))\n",
    "print(num==n)\n",
    "\n",
    "\n",
    "#without getting into lists and list comprehension, we can also use a approach similar to \n",
    "#that taken in reverse the digits\n",
    "\n",
    "#input number is in n\n",
    "\n",
    "'''\n",
    "s=0 #we will store sum in this\n",
    "num=n #mqke a copy of n\n",
    "while n!=0:\n",
    "    s=s+ ((n%10)**3)\n",
    "    n=n//10\n",
    "\n",
    "print(s==)\n",
    "\n",
    "\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fibonacci Series\n",
    "Description\n",
    "Compute and display Fibonacci series upto n terms where n is a positive integer entered by the user.\n",
    "You can go here to read about Fibonacci series.\n",
    "Sample Input:\n",
    "5\n",
    "Sample Output:\n",
    "0\n",
    "1\n",
    "1\n",
    "2\n",
    "3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "#write your code here\n",
    "n1=0\n",
    "n2=1\n",
    "sm=0\n",
    "for i in range(0,n):\n",
    "    print(n1)\n",
    "    sm=n1+n2\n",
    "    n1=n2\n",
    "    n2=sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "secondLast=0\n",
    "last=1\n",
    "if n>0:\n",
    "    print(secondLast)\n",
    "if n>1:\n",
    "    print(last)\n",
    "for i in range(3,n+1):\n",
    "    nextNumber=last+secondLast\n",
    "    print(nextNumber)\n",
    "    secondLast=last\n",
    "    last=nextNumber \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sum of Primes\n",
    "Description\n",
    "Write python code to find the sum of prime numbers from 2 to n where n is a positive integer entered by the user.\n",
    "Note: n can be non-prime or prime. You have to find sum of primes till n and not sum of n prime numbers. i.e. for input 10, output should be 17.\n",
    "Hint: You can try using lambda functions and comprehensions to reduce the lines of code you have to write.\n",
    "Sample Input:\n",
    "5\n",
    "Sample Output:\n",
    "10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "num=int(input())\n",
    "\n",
    "sm=0\n",
    "for i in range(2,num+1):\n",
    "    count=0\n",
    "    for j in range(2,i):\n",
    "        if (i%j==0):\n",
    "            count=count+1\n",
    "    if count==0:\n",
    "        sm=sm+i\n",
    "        \n",
    "print(sm)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "\n",
    "#check if the number is prime or no\n",
    "def is_prime(num):\n",
    "    for i in range(2,num):\n",
    "        if num%i==0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "s=0 #sum of primes\n",
    "for i in range(2, n+1):\n",
    "    if(is_prime(i)):\n",
    "        s=s+i\n",
    "print(s)\n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#you can solve the problem in one line as well\n",
    "#the following line is the one line solution\n",
    "#print(sum(num for num in range(2,n+1)if all(num%i!=0 for i in range(2,int(num)+1))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Smallest Element\n",
    "Description\n",
    "You have to find and print the smallest element of the list given as input. \n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A non-empty list of integers.\n",
    "\n",
    "Output:\n",
    "The smallest integer of the input list.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[2, -3, 0, 7, 21]\n",
    "\n",
    "Sample output:\n",
    "-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input have been taken for you here\n",
    "import ast\n",
    "input_str = input()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "if len(input_list)==0:\n",
    "    print('No input')\n",
    "else:\n",
    "    print(min(input_list))\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input have been taken for you here\n",
    "import ast\n",
    "input_str = input()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "#start writing your code here\n",
    "# if len(input_list)==0:\n",
    "#     print(\"no minimum\")\n",
    "# else:\n",
    "#     m=input_list[0]\n",
    "#     for item in input_list:\n",
    "#         if item < m:\n",
    "#             m = item\n",
    "#     print(m)\n",
    "\n",
    "\n",
    "print(min(input_list))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above Average\n",
    "Description\n",
    "Finding the average of the data and comparing it with other values is often encountered while analysing the data. Here you will do the same thing. The data will be provided to you in a list. You will also be given a number check.  You will return whether the number check is above average or no.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A list with two elements:\n",
    "The first element will be the list of data of integers and\n",
    "The second element will be an integer check.\n",
    "\n",
    "Output:\n",
    "True if check is above average and False otherwise\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[ [2,4,6,8,10],  4]\n",
    "\n",
    "Sample output:\n",
    "False\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[ [2,4,6,8,-10],  4]\n",
    "\n",
    "Sample output:\n",
    "True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Take input here\n",
    "#we will take input using ast sys\n",
    "import ast\n",
    "input_str = input()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "#Remember how we took input in the Alarm clock Question in previous Session?\n",
    "#Lets see if you can finish taking input on your own\n",
    "\n",
    "data=input_list[0]\n",
    "check=input_list[1]\n",
    "\n",
    "#start writing your code to find if check is above average of data \n",
    "\n",
    "avg=0\n",
    "sum=0\n",
    "\n",
    "for i in input_list[0]:\n",
    "    sum= sum+i\n",
    "\n",
    "avg=sum/(len(input_list[0]))\n",
    "\n",
    "if check>avg:\n",
    "    print('True')\n",
    "else:\n",
    "    print('False')\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Take input here\n",
    "#we will take input using ast sys\n",
    "import ast\n",
    "input_str = input()\n",
    "\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "#Remember how we took input in the Alarm clock Question in previous Session?\n",
    "#Lets see if you can finish taking input on your own\n",
    "\n",
    "data= input_list[0]\n",
    "check= input_list[1]\n",
    "\n",
    "#start writing your code to find if check is above average of data \n",
    "s=0\n",
    "for item in data:\n",
    "    s = s+ item\n",
    "\n",
    "avg = s/len(data)    \n",
    "\n",
    "if check > avg:\n",
    "    print(\"True\")\n",
    "else:\n",
    "    print(\"False\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recruit New Members\n",
    "Description\n",
    "Suppose you are a manager as a big firm and now are looking for new members for your team. You sent out an advertisement and have received a few applications. You have a habit of scoring people on a scale of 100. You have given scores to all the members of your team and the new applications. The process of selection is going to be very straightforward if the applicant improves the average of the team then you hire the applicant to join the team or else reject the application. Remember the order of processing applications is going to be important here.\n",
    "\n",
    "\n",
    "\n",
    "You may see this as an extension of the previous problem, which it is. You may use the code written in the previous question as a function to improve the code quality.\n",
    "\n",
    "\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "\n",
    "Input:\n",
    "\n",
    "Two lists on two separate lines.\n",
    "\n",
    "The first line will have the list of scores of current team members\n",
    "\n",
    "The second line will have the list of scores of the applicants.\n",
    "\n",
    "\n",
    "\n",
    "Output:\n",
    "\n",
    "The list consisting of scores of the final team after hiring from the pool of applicants.\n",
    "\n",
    "\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "\n",
    "Sample input:\n",
    "\n",
    "[23,45,34,76]\n",
    "\n",
    "[70,34,94]\n",
    "\n",
    "\n",
    "\n",
    "Sample output:\n",
    "\n",
    "[23, 45, 34, 76, 70, 94]\n",
    "\n",
    "\n",
    "Explanation:\n",
    "\n",
    "The first applicant has score 70, and the team average is 44.5 hence the applicant is hired making the team average 49.6\n",
    "\n",
    "The second applicant has score 34, and the team average is 49.6 hence the applicant is rejected keeping the team average same 49.6\n",
    "\n",
    "The third applicant has score 94, and the team average is 49.6 hence the applicant is hired making the team average 57\n",
    "\n",
    "\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "\n",
    "Sample input:\n",
    "\n",
    "[10,20,30,40,50]\n",
    "\n",
    "[30,60,80,40]\n",
    "\n",
    "\n",
    "\n",
    "Sample output:\n",
    "\n",
    "[10, 20, 30, 40, 50, 60, 80]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you have to take input on your own here\n",
    "import ast\n",
    "team=ast.literal_eval(input())\n",
    "applicant=ast.literal_eval(input())\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#write your code here\n",
    "def is_hired(data,check):\n",
    "    s=sum(data)\n",
    "    avg=s/len(team)\n",
    "    if check>avg:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "for i in applicant:\n",
    "    is_add= is_hired(team,i)\n",
    "    if is_add==1:\n",
    "        team.append(i)\n",
    "        \n",
    "print(team)\n",
    "    \n",
    "    \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you have to take input on your own here\n",
    "\n",
    "import ast\n",
    "\n",
    "team = ast.literal_eval(input())\n",
    "applicant = ast.literal_eval(input())\n",
    "\n",
    "#write your code here\n",
    "def check_above_average(data, check):\n",
    "    # s=0\n",
    "    # for item in data:\n",
    "    #     s = s+ item\n",
    "    s = sum(data)\n",
    "    avg = s/len(data)    \n",
    "    if check > avg:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "for appl in applicant:\n",
    "    is_add = check_above_average(team,appl)\n",
    "    if is_add==1:\n",
    "        team.append(appl)\n",
    "    \n",
    "print(team)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calendar\n",
    "Description\n",
    "You are planning to go to your friend's wedding and you have long events all month, lasting at least a few days. You have the start and end dates of events and your task is to find out events overlapping with the wedding date.\n",
    "\n",
    "The code for taking input has already been written for you, please don't modify that, but do read and try to understand the way input has been taken. You will be asked to take input on your own for most of the problems here onwards. Taking data in a suitable format is an important skill for a Data Scientist.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "The input will contain a list of lists where each sub-list has only two elements representing the start and end date of an event, the start date will be less than or equal to the end date. The next line of input will have a wedding date. \n",
    "\n",
    "Output:\n",
    "The output should have the number of events overlapping with the wedding date.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[ [29,31], [23,26], [24,25] ]\n",
    "24\n",
    "\n",
    "Sample output:\n",
    "2\n",
    "\n",
    "Explanation:\n",
    "There are three events in the month.\n",
    "Event 1= from date 29 to 31\n",
    "Event 2= from date 23 to 26\n",
    "Event 3= from date 24 to 25\n",
    "Wedding is on 24. This means it will clash with Event 3 and Event 2, that is two events. The output is therefore 2.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[ [1, 4], [7, 10], [8, 8], [14, 23] ]\n",
    "26\n",
    "\n",
    "Sample output:\n",
    "0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#taking input\n",
    "import ast\n",
    "input_str1 = input()\n",
    "input_list1 = ast.literal_eval(input_str1)\n",
    "events = input_list1\n",
    "\n",
    "wedding = int(input())\n",
    "\n",
    "\n",
    "#start writing from here\n",
    "clash=0\n",
    "for event in events:\n",
    "    if event[0]<=wedding and event[1]>=wedding:\n",
    "        clash=clash+1\n",
    "\n",
    "print(clash)\n",
    "        \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deep and Shallow copy is one of the most significant error encountered. To illustrate the difference let us consider the following piece of code.\n",
    "\n",
    "original_list=[0, 0, 0]\n",
    "copy1=original_list\n",
    "copy2=list(original_list)\n",
    "copy3=list.copy(original_list)\n",
    "original_list[0] = 1\n",
    "print(copy1)\n",
    "print(copy2)\n",
    "print(copy3)\n",
    " \n",
    "\n",
    "The output we were expecting is \n",
    "\n",
    "[0, 0, 0]\n",
    "[0, 0, 0]\n",
    "[0, 0, 0]\n",
    " \n",
    "\n",
    "Since all 3, copy1, copy2, copy3, are copies of original_list, any change in the original list should not be reflected in copy1, copy2 or copy3. However, the result we get is\n",
    "\n",
    "[1, 0, 0]\n",
    "[0, 0, 0]\n",
    "[0, 0, 0]\n",
    " \n",
    "\n",
    "Why is that?\n",
    "Let's dig in a little deeper. When you make ANY data structure, you ask the computer to give you some space in its memory. Now when you asked the computer for original_list‘s space in the first line, it returned you the asked space.\n",
    "\n",
    " \n",
    "\n",
    "Think of this as a box. You can store anything in this box: list, dict, anything. When you next asked copy1=original_list, you wanted a new box with its contents same as the box named original_list, but what the computer did was to give you the box named original_list instead of making a new box.\n",
    "\n",
    " \n",
    "\n",
    "Now if you make changes in the content of the box using original_list or copy1, because it is the same box it will be reflected in other as well. This is called a shallow copy. It is called a deep copy when you make the computer give you a new box as in the case of copy2 and copy3.\n",
    " Now try coding the same thing below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fenced Matrix\n",
    "Description\n",
    "You will be given two positive integers m and n. You have to make a list of lists (which can be visualised as a matrix) of size m*n, that is m sublists (rows), with each sublists having n integers (columns). The matrix should be such that it should have 1 on the border and 0 everywhere else. See sample input and output for more clarification.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "Two integers separated by a space\n",
    "\n",
    "Output:\n",
    "A list of lists of size m*n printed like matrix as shown in the sample output.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "4,5\n",
    "\n",
    "Sample output:\n",
    "[1, 1, 1, 1, 1]\n",
    "[1, 0, 0, 0, 1]\n",
    "[1, 0, 0, 0, 1]\n",
    "[1, 1, 1, 1, 1]\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "3,3\n",
    "\n",
    "Sample output:\n",
    "[1, 1, 1]\n",
    "[1, 0, 1]\n",
    "[1, 1, 1]\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "3,2\n",
    "\n",
    "Sample output:\n",
    "[1, 1]\n",
    "[1, 1]\n",
    "[1, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input on your own here\n",
    "import ast \n",
    "my_list=ast.literal_eval(input())\n",
    "\n",
    "m=my_list[0]\n",
    "n=my_list[1]\n",
    "\n",
    "\n",
    "final= [0]*n \n",
    "\n",
    "final= [list(final) for i in range(m)]\n",
    "\n",
    "for i in range(m):\n",
    "    for j in range(n):\n",
    "        if i==0 or j==0 or i==m-1 or j==n-1:\n",
    "            final[i][j]=1\n",
    "            \n",
    "\n",
    "for i in final:\n",
    "    print(i)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#start writing code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "in_str=input()\n",
    "in_str=in_str.split(',')\n",
    "m=int(in_str[0])\n",
    "n=int(in_str[1])\n",
    "\n",
    "#make a list with n zeroes\n",
    "final=[0]*n\n",
    "\n",
    "#make a matrix of m such lists\n",
    "final=[list(final) for i in range(m)]\n",
    "for i in range(m):\n",
    "    for j in range(n):\n",
    "        if i==0 or j==0 or i==m-1 or j==n-1:\n",
    "            final[i][j]=1\n",
    "            \n",
    "#print in the fashion as shown in Sample output\n",
    "for i in final:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lego Stack\n",
    "Description\n",
    "You are given a row of Lego Blocks consisting of n blocks. All the blocks given have a square base whose side length is known. You need to stack the blocks over each other and create a vertical tower. Block-1 can go over Block-2 only if sideLength(Block-2)=>sideLength(Block-1).\n",
    "From the row of Lego blocks, you on only pick up either the leftmost or rightmost block.\n",
    "Print \"Possible\" if it is possible to stack all n cubes this way or else print \"Impossible\".\n",
    "\n",
    "Input Format:\n",
    "The input will contain a list of n integers representing the side length of each block's base in the row starting from the leftmost.\n",
    "\n",
    "Sample Input:\n",
    "[5 ,4, 2, 1, 4 ,5]\n",
    "Sample Output:\n",
    "Possible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast\n",
    "\n",
    "my_list=ast.literal_eval(input())\n",
    "\n",
    "first=my_list[0]\n",
    "count=0\n",
    "for i in my_list:\n",
    "    if my_list[0]>=first or my_list[-1]>=first:\n",
    "        count=count+1\n",
    "    else:\n",
    "        pass\n",
    "if count==len(my_list):\n",
    "    print('Possible')\n",
    "else:\n",
    "    print('Impossible')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast\n",
    "input_str = input()\n",
    "sides = ast.literal_eval(input_str)#list of side lengths\n",
    "\n",
    "#we will make a tower by taking the larger lego(brick) from one of the ends \n",
    "#of the list and then remove that element\n",
    "tower=[]\n",
    "\n",
    "while sides: #while sides is not empty\n",
    "    if sides[0]>=sides[-1]:\n",
    "        tower.append(int(sides[0]))\n",
    "        sides.pop()\n",
    "    else:\n",
    "        tower.append(int(sides[-1]))\n",
    "        sides.pop(-1)\n",
    "\n",
    "#now we check if all the elements are in descending order in tower\n",
    "flag=1\n",
    "for i in range(len(tower)-2):\n",
    "    if tower[i]<tower[i+1]:\n",
    "        flag=0\n",
    "        break\n",
    "if(flag==1):\n",
    "    print('Possible')\n",
    "else:\n",
    "    print('Impossible')\n",
    "    \n",
    "#you can try the below solution as well\n",
    "'''\n",
    "l=len(sides)\n",
    "diff = [(sides[i]-sides[i+1]) for i in range(l-1)]\n",
    "i = 0 \n",
    "while (i<l-1 and diff[i]>=0) : i += 1 \n",
    "while (i<l-1 and diff[i]<=0) : i += 1\n",
    "if (i==l-1) : print(\"Possible\") \n",
    "else : print(\"Impossible\")\n",
    "\n",
    "#to understand the code, try printing out all intermediate variables.\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Break the list\n",
    "Description\n",
    "Write a Python program to divide a given list into chunks of size k.\n",
    "\n",
    "The number of elements in the list need not to be divisible by k.\n",
    "For example, if you want to divide the list [1,2,3,4,5,6,7] into chunk size k=4, then the first chunk will be [1,2,3,4] and the second one will have [5,6,7]. i.e. the last chunk need not have k elements.\n",
    "The input will have two lines, the first line would have the list and the second line would have the value of k.(the code for taking input has already been written, you should not change that)\n",
    "The final output should have the list chunks in different lines.\n",
    "\n",
    "Sample Input:\n",
    "[1,2,3,4,5,6,7,8,9]\n",
    "3\n",
    "Sample Output:\n",
    "\n",
    "[1, 2, 3]\n",
    "[4, 5, 6]\n",
    "[7, 8, 9]\n",
    "\n",
    "A similar question was asked in a Data Analyst test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "lis=input_list[0]\n",
    "k=input_list[1]\n",
    "\n",
    "def divide_chunks(l, k):  \n",
    "    for i in range(0, len(l), k):  \n",
    "        list= l[i:i + k] \n",
    "        print(list)    \n",
    "\n",
    "(divide_chunks(lis,k))\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "import ast\n",
    "input_str = input()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "lis=input_list[0]\n",
    "k=input_list[1]\n",
    "\n",
    "\n",
    "for i in range(0, len(lis), k):  \n",
    "    print(lis[i: i + k]) #remember list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Second Maximum Number in a List\n",
    "Description\n",
    "Given a list of numbers, find the second largest number in the list.\n",
    "\n",
    "Note: There might be repeated numbers in the list. If there is only one number present in the list, return 'not present'.\n",
    "\n",
    "Examples:\n",
    "Input 1:\n",
    "[7, 2, 0, 9, -1, 8]\n",
    "Output 1:\n",
    "8\n",
    "\n",
    "Input 2:\n",
    "[3, 1, 4, 4, 5, 5, 5, 0, 2, 2]\n",
    "Output 2:\n",
    "4\n",
    "\n",
    "Input 2:\n",
    "[6, 6, 6, 6, 6]\n",
    "Output 2:\n",
    "not present"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input list\n",
    "import ast,sys\n",
    "from itertools import groupby\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "list1=[i[0] for i in groupby(input_list)]\n",
    "# Write your code here\n",
    "if len(list1)==0:\n",
    "    print(\"no maximum\")\n",
    "    \n",
    "elif len(list1)==1:\n",
    "    print('not present')\n",
    "else:\n",
    "    largest=list1[0]\n",
    "    sec_largest=None\n",
    "    for item in list1:\n",
    "        if item > largest:  \n",
    "            sec_largest = largest \n",
    "            largest = item  \n",
    "        elif sec_largest == None or sec_largest < item:  \n",
    "            sec_largest = item\n",
    "    print(sec_largest)\n",
    "            \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pascal's Triangle\n",
    "Description\n",
    "A pascal's triangle is a very interesting mathematical concept.\n",
    "Each number here is a sum of the two numbers directly above it.\n",
    "Following is an 8 level Pascal's triangle:﻿\n",
    "﻿\n",
    "You can read about Pascal's triangle here.\n",
    "Your task is to print an nth level of Pascal's triangle.\n",
    "The input will contain an integer n.\n",
    "The output will contain 1 line of the list of numbers representing the nth row of Pascal's triangle.\n",
    "\n",
    "Sample Input:\n",
    "6\n",
    "Sample Output:\n",
    "\n",
    "[1, 5, 10, 10, 5, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been taken for you\n",
    "n=int(input())\n",
    "\n",
    "def pascal(n):\n",
    "    line = [1]*n \n",
    "    for i in range(n):\n",
    "        last_line=line.copy()\n",
    "        for j in range(1,i):\n",
    "            line[j]= last_line[j-1] + last_line[j]\n",
    "    return line\n",
    "   \n",
    "print(pascal(n))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "\n",
    "# we will make a list with n lists in it\n",
    "# each nth list will have n numbers\n",
    "#we put all 1 in all sub lists\n",
    "#suppose n = 4\n",
    "Pascals=[[1 for i in range(j)] for j in range(1, n+1)]\n",
    "#Pascals = [[1], [1, 1], [1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1]]\n",
    "#we dont need to change first two sublists\n",
    "for i in range(2, n):\n",
    "    for j in range(1,i):\n",
    "        Pascals[i][j]=Pascals[i-1][j-1]+Pascals[i-1][j]\n",
    "        #we add from previous sublist as shown in the link\n",
    "\n",
    "print(Pascals[-1]) #print last element of the list\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Palindrome String\n",
    "Description\n",
    "Write a program to check whether a string is a palindrome or not. Print 1 if the string is a palindrome and 0 otherwise.\n",
    "\n",
    "Note: Please ensure that your program should not be case-sensitive. So, if the input is, say, “HAnnah”, then, its output should be 1.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A string\n",
    "\n",
    "Output:\n",
    "1 if the string is a palindrome, 0 otherwise\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "HAnnah\n",
    "\n",
    "Sample output:\n",
    "1\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "Rebecca\n",
    "\n",
    "Sample output:\n",
    "0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input\n",
    "s = input()\n",
    "\n",
    "#check for palindrome here\n",
    "\n",
    "s=s.lower()\n",
    "\n",
    "r=''\n",
    "\n",
    "for i in s:\n",
    "    r=i+r \n",
    "\n",
    "if s==r:\n",
    "    print(1)\n",
    "else:\n",
    "    print(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input\n",
    "s = input()\n",
    "\n",
    "#check for palindrome here\n",
    "\n",
    "# Convert all the characters of the string to lowercase so that your program is\n",
    "# not case-sensitive. You can also use 'lower()', alternatively.\n",
    "s = s.lower()\n",
    "\n",
    "# Initialise your reversed string as an empty string and store it in a variable\n",
    "# called \"r\"\n",
    "r =\"\"\n",
    "\n",
    "# Run a loop throughout the length of the string\n",
    "for i in s:\n",
    "# Keep adding the current character to rev_str, i.e. the string reversed so far.\n",
    "# Make sure 'i' is kept before 'r' in the addition process or you will get\n",
    "# the r exactly same as the original string.\n",
    "    r = i+r\n",
    "\n",
    "# Compare the reversed and the original string. If they are the same, the string\n",
    "# is a palindrome; otherwise it is not a palindrome.\n",
    "if r==s:\n",
    "    print(1)\n",
    "else:\n",
    "    print(0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse Words\n",
    "Description\n",
    "You will be given a sentence in the form of a string. You have to reverse the order of the words in the sentence. Remember not to reverse the individual words, but the order of words. Check the sample input-output for further clarification.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A string, which will consist of a few spaces.\n",
    "\n",
    "Output:\n",
    "The words in reverse order.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "I love coding in python\n",
    "\n",
    "Sample output:\n",
    "python in coding love I\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "python is super easy and fun\n",
    "\n",
    "Sample output:\n",
    "fun and easy super is python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "\n",
    "sentence=input()\n",
    "\n",
    "#reverse the words of the sentence here\n",
    "\n",
    "mylist= sentence.split(' ')\n",
    "mylist.reverse()\n",
    "\n",
    "final= ' '.join(mylist)\n",
    "\n",
    "print(final)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "#no need to change input as its in string form\n",
    "sentence=input()\n",
    "\n",
    "#reverse the words of the sentence here\n",
    "\n",
    "#first separate the words by spliting with space\n",
    "words = sentence.split(' ')\n",
    "\n",
    "#reversed_list = words[::-1]\n",
    "#reverse this list\n",
    "words.reverse()\n",
    "\n",
    "#join using space\n",
    "final_string = ' '.join(words)\n",
    "\n",
    "print(final_string)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse Words\n",
    "Description\n",
    "You will be given a sentence in the form of a string. You have to reverse the order of the words in the sentence. Remember not to reverse the individual words, but the order of words. Check the sample input-output for further clarification.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A string, which will consist of a few spaces.\n",
    "\n",
    "Output:\n",
    "The words in reverse order.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "I love coding in python\n",
    "\n",
    "Sample output:\n",
    "python in coding love I\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "python is super easy and fun\n",
    "\n",
    "Sample output:\n",
    "fun and easy super is python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "\n",
    "sentence=input()\n",
    "\n",
    "#reverse the words of the sentence here\n",
    "\n",
    "mylist= sentence.split(' ')\n",
    "mylist.reverse()\n",
    "\n",
    "final= ' '.join(mylist)\n",
    "\n",
    "print(final)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "#no need to change input as its in string form\n",
    "sentence=input()\n",
    "\n",
    "#reverse the words of the sentence here\n",
    "\n",
    "#first separate the words by spliting with space\n",
    "words = sentence.split(' ')\n",
    "\n",
    "#reversed_list = words[::-1]\n",
    "#reverse this list\n",
    "words.reverse()\n",
    "\n",
    "#join using space\n",
    "final_string = ' '.join(words)\n",
    "\n",
    "print(final_string)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No Spaces\n",
    "Description\n",
    "While naming entities, it is a common practice to avoid spaces. That is the reason you see so many people using underscores instead of spaces. \n",
    "You will be given a string, containing a few spaces and random upper and lower cases. You have to write a code that will add underscore in place of spaces and also capitalise the letters properly, i.e. the first letter after underscore should be in upper case and the first letter of the string should be in upper case, all of the other letters should be lower case. \n",
    "This type of activity is frequently encountered while starting to analyse data. This is called Data cleaning and you will learn more about it in upcoming modules.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A string of only alphabets and spaces\n",
    "\n",
    "Output:\n",
    "A string formatted as stated above. See sample input/output for more clarification,\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "caloRie consuMed\n",
    "\n",
    "Sample output:\n",
    "Calorie_Consumed\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "data science\n",
    "\n",
    "Sample output:\n",
    "Data_Science"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "s=input()\n",
    "\n",
    "#write code to format the string s as asked \n",
    "\n",
    "s=s.lower()\n",
    "words=s.split(' ')\n",
    "\n",
    "\n",
    "final= [word[0].upper()+word[1:] for word in words]\n",
    "    \n",
    "final_list= '_'.join(final)\n",
    "\n",
    "print(final_list)\n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "s=input()\n",
    "\n",
    "#write code to format the string s as asked \n",
    "\n",
    "#first change the all characters to lower\n",
    "s= s.lower()\n",
    "\n",
    "#split it with space\n",
    "words = s.split(' ')\n",
    "\n",
    "#make all of them capital at first letter\n",
    "#final_list = [word[0].upper() + word[1:] for word in words]\n",
    "final_list = [word.title() for word in words]\n",
    "\n",
    "#join using _ \n",
    "final_string = '_'.join(final_list)\n",
    "\n",
    "print(final_string)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Shift Vowels\n",
    "Description\n",
    "Write a program that receives a string and shifts all the vowels present in it to the beginning. Output the resultant string. The order of all the vowels with respect to each other as well as the order of all the other characters with respect to each other should stay the same.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A string\n",
    "\n",
    "Output:\n",
    "Vowels shifted to the beginning in the input string.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "programming\n",
    "\n",
    "Sample output:\n",
    "oaiprgrmmng\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "You love Python!\n",
    "\n",
    "Sample output:\n",
    "ouoeoY lv Pythn!\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Explanation:\n",
    "All the vowels have been shifted to the beginning in order. The order of all the other characters remains the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input string\n",
    "\n",
    "s = input()\n",
    "\n",
    "v=''\n",
    "c=''\n",
    "\n",
    "vow=['a','e','i','o','u']\n",
    "\n",
    "for i in s:\n",
    "    if i.lower() in vow:\n",
    "        v=v+i\n",
    "    else:\n",
    "        c=c+i\n",
    "        \n",
    "\n",
    "print(v+c)\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input string \n",
    "s = input()\n",
    "\n",
    "\n",
    "vowel = \"\"\n",
    "others = \"\"\n",
    "\n",
    "\n",
    "for i in range(len(s)):\n",
    "    \n",
    "\n",
    "    if s[i] in \"aeiou\":\n",
    "        vowel = vowel + s[i]\n",
    "        \n",
    "#\n",
    "    else:\n",
    "        others = others + s[i]\n",
    "\n",
    "    \n",
    "final = vowel + others\n",
    "\n",
    "# Print the value of the final string\n",
    "print(final)\n",
    "\n",
    "\n",
    "# Read the input string\n",
    "\n",
    "s = input()\n",
    "\n",
    "vowels = \"aeiouAEIOU\"\n",
    "\n",
    "# Declare two empty strings: \"v\" and \"o\" which will contain all the vowels\n",
    "# and the other characters respectively\n",
    "v=\"\"\n",
    "o=\"\"\n",
    "\n",
    "# Run a loop throughout the length of the string \n",
    "for i in s:\n",
    "    # If the current character is a vowel, append it to the v string\n",
    "    if i in vowels:\n",
    "        v=v+i\n",
    "    # Else, append it to the others string\n",
    "    else:\n",
    "        o=o+i\n",
    "\n",
    "# Add the v and o string in order and store it in a new variable - final_string    \n",
    "final_string = v+o\n",
    "\n",
    "print(final_string)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Common Prefix\n",
    "Description\n",
    "You will be given two strings. You have to find the largest prefix common in both the strings.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "Two lines of input, one string on each line\n",
    "\n",
    "Output:\n",
    "The common largest prefix for both strings. Check sample input/output for clarification. -1 if no prefix is common.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "abshdksajd\n",
    "abshiehand\n",
    "\n",
    "Sample output:\n",
    "absh\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "upgradData\n",
    "upGradScience\n",
    "\n",
    "Sample output:\n",
    "upgrad\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Note: the last sample input/output clearly shows the code is not case sensitive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been taken for you\n",
    "\n",
    "string1=input()\n",
    "string2=input()\n",
    "\n",
    "string1=string1.lower()\n",
    "string2=string2.lower()\n",
    "\n",
    "\n",
    "\n",
    "#start writing your code to find largest common prefix here\n",
    "\n",
    "l1=len(string1)\n",
    "l2=len(string2)\n",
    "\n",
    "min_len= min(l1,l2)\n",
    "\n",
    "for i in range(min_len):\n",
    "    if string1[i]!=string2[i]:\n",
    "        break\n",
    "    \n",
    "if i==0:\n",
    "    print(-1)\n",
    "else:\n",
    "    print(string1[:i])\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been taken for you\n",
    "\n",
    "string1=input()\n",
    "string2=input()\n",
    "\n",
    "#make them all lower\n",
    "string1 = string1.lower()\n",
    "string2 = string2.lower()\n",
    "\n",
    "#start writing your code to find largest common prefix here\n",
    "#first we find the length of smaller string as that can be the longest prefix possible\n",
    "#checking beyond that is pointless\n",
    "l1 = len(string1)\n",
    "l2 = len(string2)\n",
    "min_len = min(l1,l2)\n",
    "\n",
    "#we will check all characters one by one upto min_len in both strings and \n",
    "#break the loop whereever we find that they are not matching\n",
    "for i in range(min_len):\n",
    "    if string1[i] != string2[i]:\n",
    "        break\n",
    "#if i is zero, that means first element is not matching\n",
    "#value of i here indicate what index is not matching\n",
    "if i==0:\n",
    "    print(-1)\n",
    "#if there is atleast one matching prefixx string\n",
    "else:\n",
    "    print(string1[:i])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anagrams\n",
    "Description\n",
    "Two strings are anagrams of each other if you can rearrange the characters of one string to make the other string.\n",
    "Given two strings, can you find if they are anagrams or no?\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "Two lines of input, each line will contain a string without space.\n",
    "\n",
    "Output:\n",
    "True or False based on whether the strings are anagrams or not.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "thing\n",
    "night\n",
    "\n",
    "Sample output:\n",
    "True\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "upgrad\n",
    "found\n",
    "\n",
    "Sample output:\n",
    "False\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Note: the code will be case-Sensitive\n",
    "Hint: if the length of the strings doesn't match, the strings are obviously not anagrams."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "s1=input()\n",
    "s2=input()\n",
    "\n",
    "#code here to check if they are anagrams or no\n",
    "def anagram(s1,s2):\n",
    "    if len(s1)!=len(s2):\n",
    "        return False\n",
    "    for i in  range(len(s1)):\n",
    "        if s1.count(s1[i])!=s2.count(s1[i]):\n",
    "            return False\n",
    "    return True\n",
    "    \n",
    "print(anagram(s1,s2))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "s1 = input()\n",
    "s2 = input()\n",
    "\n",
    "#code here to check if they are anagrams or no\n",
    "\n",
    "def anagram(s1,s2):\n",
    "    #if length doesnt match then they are definitely not anagrams\n",
    "    if len(s1)!=len(s2):\n",
    "        return False\n",
    "    \n",
    "    #we will check count of each character one by one\n",
    "    for i in range(len(s1)):\n",
    "        if s1.count(s1[i]) != s2.count(s1[i]):\n",
    "            return False\n",
    "   #if we come out of the for loop means we didnt exit the function in loop\n",
    "   #remember we exit the function when we return\n",
    "   #this means there was no occurance where s1.count(s1[i]) != s2.count(s1[i]) was True\n",
    "   #this means the strings are anagrams\n",
    "    return True\n",
    "\n",
    "print(anagram(s1,s2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find Extra Character\n",
    "Description\n",
    "Given two strings, one of the strings will contain an extra character. Find the extra character. The number of all the other characters in both the strings will be the same. Check the sample input/output for more clarification.\n",
    "\n",
    "The code will be case sensitive.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "Two strings on two separate lines. \n",
    "\n",
    "Output:\n",
    "One Character which is extra in one of the strings\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "abcd\n",
    "cedab\n",
    "\n",
    "Sample output:\n",
    "e\n",
    "Execution Time Limit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input on your own\n",
    "\n",
    "s1=input()\n",
    "s2=input()\n",
    "\n",
    "\n",
    "#write code to find the extra character here\n",
    "\n",
    "if len(s1)>len(s2):\n",
    "    max_len=s1\n",
    "    min_lin=s2\n",
    "else:\n",
    "    min_len=s1\n",
    "    max_len=s2\n",
    "    \n",
    "for i in max_len:\n",
    "    if i not in min_len:\n",
    "        var= i\n",
    "        print(var)\n",
    "        \n",
    "    \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input on your own\n",
    "string1=input()\n",
    "string2=input()\n",
    "\n",
    "\n",
    "#write code to find the extra character here\n",
    "\n",
    "#we will iterate over longer string\n",
    "#first we find longer string\n",
    "if len(string2)>len(string1):\n",
    "    longer=string2\n",
    "else:\n",
    "    longer=string1\n",
    "#we then iterate over longer string checking count\n",
    "#of that character in both strings\n",
    "\n",
    "for i in longer:\n",
    "    if string1.count(i)!=string2.count(i):\n",
    "        print(i)\n",
    "        break\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integer or String\n",
    "Description\n",
    "You have been using ast.literal_eval() to take input in a suitable format. Have you thought of how does it distinguish between different data types and data structures? We will solve a similar but smaller problem here. You will be given a string as input. You just have to determine if the string can be an integer or no?\n",
    "This is also encountered a lot in Data Science. Upon taking a lot of data, sometimes integer values are treated as a string, and due to that a lot of functionalities of integer data which you will learn ahead are rendered useless.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A single line of string\n",
    "\n",
    "Output:\n",
    "INT if the input string is an integer and STR otherwise.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "12\n",
    "\n",
    "Sample output:\n",
    "INT\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "12.4\n",
    "\n",
    "Sample output:\n",
    "STR\n",
    "\n",
    "Explanation: You only have to print INT if its an integer, in this case, it is a float.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "43a\n",
    "\n",
    "Sample output:\n",
    "STR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#inut has been taken for you\n",
    "\n",
    "in_str=input()\n",
    "\n",
    "l= in_str.replace('+','').replace('-','')\n",
    "\n",
    "#find out if in_str is integer or not\n",
    "if l.isdigit():\n",
    "    print('INT')\n",
    "else:\n",
    "    print('STR')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#inut has been taken for you\n",
    "in_str=input()\n",
    "\n",
    "#find out if in_str is integer or not\n",
    "\n",
    "#first we strip all spaces in start and end of the string\n",
    "in_str=in_str.strip()\n",
    "\n",
    "isstring=0 #we will make this variable as 1 if it fails to be an integer at any point \n",
    "nums='0123456789'\n",
    "#lets break it down in three possibilites: in_str is a positive integer\n",
    "#or a negative integer or a string\n",
    "\n",
    "#incase of positive or negative integer all characters other\n",
    "#than first character (0th index) must be in nums\n",
    "\n",
    "for i in in_str[1:]:\n",
    "    if i not in nums:\n",
    "        isstring=1\n",
    "\n",
    "#now we check first character (zeroth index)\n",
    "if in_str[0] not in nums+'-': \n",
    "    isstring=1 #it will be string if first element is not - or 0123456789\n",
    "\n",
    "if isstring:\n",
    "    print('STR')\n",
    "else:\n",
    "    print('INT')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clean Numbers\n",
    "Description\n",
    "While extracting data from different sources, often numeric values come in string format and with commas like 1,000 or 23,321 and also sometimes with spaces in start and beginning of the string. For simplicity, we will consider only integer values imbedded with commas. You will take the input and print the cleaned integer without commas and spaces.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "One line input of string, it will consist of only spaces commas and digits\n",
    "\n",
    "Output:\n",
    "Cleaned number\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "         3,213\n",
    "\n",
    "Sample output:\n",
    "3213\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "4,68,72,352          \n",
    "\n",
    "Sample output:\n",
    "46872352\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Note: Spaces will be either in the start or at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been take  for you\n",
    "value=input()\n",
    "\n",
    "new_value= value.replace(',','').replace(' ','')\n",
    "\n",
    "print(new_value)\n",
    "\n",
    "\n",
    "\n",
    "#start writing your code from here\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been take  for you\n",
    "value=input()\n",
    "\n",
    "#start writing your code from here\n",
    "\n",
    "#first we strip all the spaces\n",
    "value=value.strip()\n",
    "\n",
    "#we will split it at commas and then join it back and then convert to int\n",
    "value_list=value.split(',')\n",
    "final_value= int( ''.join(value_list) )\n",
    "print(final_value)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Secret Message\n",
    "Description\n",
    "You write all your passwords in a diary so that you don't forget them. But clearly this is too risky, so you came up with a simple plan, you will simply write it by shifting all the alphabets by a certain step. For eg: if you decide your step to be 3, then 'a' will become 'd', and 'k' will become 'n' and so for all alphabets. The last alphabets will simply circle back to 'a'. In this case, 'y' will become 'b' and so on. Now you just have to remember the step size, can then you can check the password anytime you want. You decided to write code to do this, now that you have learned coding in python. Your code will take in the step size and what is written in the diary and give out the real password.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A list of two elements.\n",
    "The first element will be a string consisting of only alphabets which is taken from the diary and the second element will be the step size.\n",
    "\n",
    "Output:\n",
    "A string denoting the password\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "['ytKveh' 4]\n",
    "\n",
    "Sample output:\n",
    "upGrad\n",
    "\n",
    "Explanation:\n",
    "The password was 'upGrad'. Upon changing it by step of 4,\n",
    "u became y,\n",
    "p became t,\n",
    "G became K,\n",
    "r became v,\n",
    "a became e,\n",
    "d became h,\n",
    "and thus what was written in the diary was ytKveh \n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "['banana', 7]\n",
    "\n",
    "Sample output:\n",
    "utgtgt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input on your own\n",
    "import ast \n",
    "input_str=ast.literal_eval(input())\n",
    "pw=input_str[0]\n",
    "step_size=input_str[1]\n",
    "new_pw=''\n",
    "for i in pw:\n",
    "    asci_val= ord(i)\n",
    "    if(asci_val>=65 and asci_val<=90):\n",
    "        asci_step = asci_val-step_size\n",
    "        if(asci_step<65):\n",
    "            diff = (65-asci_step)-1\n",
    "            letter =chr(90-diff)\n",
    "        else:\n",
    "            letter=chr(asci_step)\n",
    "    else:\n",
    "        #(asci_val>=97 and asci_val<=122)\n",
    "        asci_step = asci_val-step_size\n",
    "        if(asci_step<97):\n",
    "            diff = (97-asci_step)-1\n",
    "            letter =chr(122-diff)\n",
    "        else:\n",
    "            letter=chr(asci_step)\n",
    "    new_pw= new_pw+letter\n",
    "    \n",
    "print(new_pw)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input on your own\n",
    "#we use ast.literal_eval to take input\n",
    "import ast\n",
    "inp=ast.literal_eval(input())\n",
    "#start writing your code from here\n",
    "\n",
    "#password is what is written in diary\n",
    "password=inp[0]\n",
    "step=inp[1]\n",
    "\n",
    "\n",
    "#we first make list of alphabets in same order \n",
    "#we will now use this to travel the number of steps\n",
    "lower=[chr(i) for i in range(ord('a'), ord('z')+1)]\n",
    "upper=[chr(i) for i in range(ord('A'), ord('Z')+1)]\n",
    "\n",
    "#we will take each character from password, take steps and find the real\n",
    "#character corresponding to it and append it in real_pass string\n",
    "real_pass=''\n",
    "\n",
    "for i in password:\n",
    "   #because it is given in question that the string password will be only of alphabets\n",
    "   #its either in lower or in upper \n",
    "    if i in lower:\n",
    "        char_num=lower.index(i) #this will find the index of the character in the list\n",
    "        char_num=(char_num-step)%26 #mod 26 will give us the value in 0-25\n",
    "        real_pass=real_pass+lower[char_num] #append it in real_pass\n",
    "    \n",
    "    #same if it is in upper \n",
    "    else: \n",
    "        char_num=upper.index(i)\n",
    "        char_num=(char_num-step+26)%26\n",
    "        real_pass=real_pass+upper[char_num]\n",
    "\n",
    "\n",
    "print(real_pass)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A weird sum\n",
    "Description\n",
    "Write a program that computes the value of n+nn+nnn+nnnn+... nn...n ntimes with a given number as the value of n.\n",
    "\n",
    "\n",
    "\n",
    "For example, if n=3 , then you have to find the value of 3+33+333\n",
    "\n",
    "if n=10, then you have to find the value of 10 + 1010 + 101010 + 10101010 + 1010101010 + 101010101010 + 10101010101010 + 1010101010101010 + 101010101010101010+10101010101010101010\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Note: n will always be a positive number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "n=input()\n",
    "\n",
    "#start writing your code here\n",
    "total=0\n",
    "s=int(n)\n",
    "for i in range(1,s+1):\n",
    "    sum=(n*i)\n",
    "    total=int(sum)+int(total)\n",
    "print(total)\n",
    "        \n",
    "    \n",
    "\n",
    "        \n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=input()\n",
    "\n",
    "#start writing your code form here\n",
    "answer=0\n",
    "\n",
    "for i in range(1,n+1):\n",
    "    num=''\n",
    "    for j in range(i):\n",
    "        num=num+str(n)\n",
    "    num=int(num)\n",
    "    answer=answer+num\n",
    "\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove Duplicates\n",
    "Description\n",
    "Sometimes the data has few duplicate values which will affect the analysis done. In this problem, you will be given a list. You have to find and delete the duplicates and print the updated list with no duplicates.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A list of integers.\n",
    "\n",
    "Output:\n",
    "A list of integers, with duplicates removed if any.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[8, 9, 2, 2, 3, 4, 5, 2]\n",
    "\n",
    "Sample output:\n",
    "[8, 9, 2, 3, 4, 5]\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[4, 4, 4, 4]\n",
    "\n",
    "Sample output:\n",
    "[4]\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Note the order of the data did not change in input and output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "import ast \n",
    "\n",
    "my_list= ast.literal_eval(input())\n",
    "\n",
    "\n",
    "\n",
    "#remove duplicates from the list\n",
    "\n",
    "d= {}\n",
    "\n",
    "#print the list without duplicates\n",
    "for item in my_list:\n",
    "    if item not in d:\n",
    "        d[item]= 1\n",
    "    \n",
    "print(list(d.keys()))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "import ast\n",
    "\n",
    "mylist = ast.literal_eval(input())\n",
    "\n",
    "#remove duplicates from the list\n",
    "d = {}\n",
    "\n",
    "for item in mylist:\n",
    "    if item not in d:\n",
    "        d[item]=1\n",
    "#     # else:\n",
    "#     #     d[item]= d[item]+1\n",
    "\n",
    "print(list(d.keys()))\n",
    "\n",
    "#print the list without duplicates\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionary And List\n",
    "Description\n",
    "You will be converting a dictionary, of string(keys) and list of string (values),  to a list of strings. Please check the sample input/output for clarification.\n",
    "\n",
    "\n",
    "Input:\n",
    "A dictionary with keys as strings and values as a list of strings.\n",
    "\n",
    "Output:\n",
    "A list of strings\n",
    "\n",
    "\n",
    "Sample input:\n",
    "{‘Mobile’: [‘Redmi’, ‘Samsung’, ‘Realme’], \n",
    "‘Laptop’: [‘Dell’, ‘HP’],\n",
    "‘TV’: [‘Videocon’, ‘Sony’] }\n",
    "\n",
    "Sample output:\n",
    "[‘Mobile_Redmi’, ‘Mobile_Samsung’, ‘Mobile_Realme’, ‘Laptop_Dell’, ‘Laptop_HP’, ‘TV_Videocon’, ‘TV_Sony’]\n",
    "\n",
    "\n",
    "Sample input:\n",
    "{ 'Pen': ['Gel', 'Ink', 'ball'],\n",
    "'Mobile': ['Android', 'apple'] }\n",
    "\n",
    "Sample output:\n",
    "['Pen_Gel', 'Pen_Ink', 'Pen_ball', 'Mobile_Android', 'Mobile_apple']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been taken for you\n",
    "import ast\n",
    "input_str = input()\n",
    "#input dictionary has been received in input_dict\n",
    "input_dict = ast.literal_eval(input_str)\n",
    "\n",
    "l=[]\n",
    "\n",
    "\n",
    "\n",
    "#start writing your code here\n",
    "\n",
    "for key in input_dict.keys():\n",
    "    for word in input_dict[key]:\n",
    "        l.append(key+'_'+word)\n",
    "        \n",
    "print(l)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been taken for you\n",
    "import ast\n",
    "input_str = input()\n",
    "#input dictionary has been received in input_dict\n",
    "input_dict = ast.literal_eval(input_str)\n",
    "\n",
    "\n",
    "#start writing your code here\n",
    "final_list=[] #this is the list we will print at the end\n",
    "for key in input_dict.keys(): #we will travel to each key\n",
    "    for word in input_dict[key]:\n",
    "        final_list.append(str(key)+'_'+str(word)) #append the string with key and values with _ \n",
    "\n",
    "print(final_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "upGrad String\n",
    "Description\n",
    "For the purpose of this question, we will define something called an upGrad string. Note that this definition is not valid outside this question. A string upGrad string if the frequency of its characters is something like 1, 2, 3, 4, .... That is a character appears only once, another appears twice, another appears thrice and so on. For example string '$yrr$ssrsr' is a beautiful string since the frequency of y:1, $:2, s:3, r:4, however string '$yrr$ssrsr%' will not be beautiful since it has two characters (y and %) with frequency 1. The frequency of characters should be of form 1, 2, 3, 4, 5... only.\n",
    "Given a string, can you determine if the string is upGrad string or no?\n",
    "\n",
    "\n",
    "Input:\n",
    "A string\n",
    "\n",
    "Output:\n",
    "Boolean depending whether the string is upGrad string or not\n",
    "\n",
    "\n",
    "Sample input:\n",
    "$yrr$ssrsr\n",
    "\n",
    "Sample output:\n",
    "True\n",
    "\n",
    "\n",
    "Sample input:\n",
    "$yrr$ssrsr%\n",
    "\n",
    "Sample output:\n",
    "False\n",
    "\n",
    "Sample input:\n",
    "ab#ab#aba\n",
    "\n",
    "Sample output:\n",
    "False\n",
    "\n",
    "Sample input:\n",
    "ab#ab#ab6a\n",
    "\n",
    "Sample output:\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been taken for you\n",
    "import ast \n",
    "s=input()\n",
    "\n",
    "d={}\n",
    "d1={}\n",
    "\n",
    "#start writing your code to check if s is upgrad string or no\n",
    "for c in s:\n",
    "    if c not in d:\n",
    "        d[c]= 1\n",
    "    else:\n",
    "        d[c]=d[c]+1\n",
    "    \n",
    "l= len(d)\n",
    "vals= d.values()\n",
    "def upgrad_string(vals):\n",
    "    for i in range(1,l+1):\n",
    "        if i not in vals:\n",
    "            return False\n",
    "    return True\n",
    "            \n",
    "print(upgrad_string(vals))\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been taken for you\n",
    "s=input()\n",
    "\n",
    "#start writing your code to check if s is upgrad string or no\n",
    "d={}\n",
    "\n",
    "for i in s:\n",
    "    if i not in d:\n",
    "        d[i] =1\n",
    "    else:\n",
    "        d[i] = d[i]+1\n",
    "\n",
    "vals = d.values()\n",
    "\n",
    "n = len(d)\n",
    "\n",
    "def upgrad_string(vals):\n",
    "    for i in range(1,n+1):\n",
    "        if i not in vals:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "print(upgrad_string(vals))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Balanced Brackets\n",
    "Description\n",
    "You will be given a string with a lot of brackets. You have to print if the brackets are balanced or not. Remember, there are three types of brackets: ‘( )’,  ‘{ }’ and ‘[ ]’.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A string\n",
    "\n",
    "Output:\n",
    "Yes, if the brackets are balanced.\n",
    "No otherwise.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "){[[]]}())()\n",
    "\n",
    "Sample output:\n",
    "No\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input 2:\n",
    "[](){[]()(){}}\n",
    "\n",
    "Sample output 2:\n",
    "Yes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input\n",
    "inp=input()\n",
    "\n",
    "stack=[]\n",
    "\n",
    "for i in inp:\n",
    "    if len(stack)==0:\n",
    "        stack.append(i)\n",
    "    else:\n",
    "        if i==')' and stack[-1]=='(':\n",
    "            stack.pop()\n",
    "        elif i=='}' and stack[-1]=='{':\n",
    "            stack.pop()\n",
    "        elif i==']' and stack[-1]=='[':\n",
    "            stack.pop()\n",
    "        else:\n",
    "            stack.append(i)\n",
    "            \n",
    "if stack:\n",
    "    print('No')\n",
    "else:\n",
    "    print('Yes')\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cheapest Item\n",
    "Description\n",
    "You will be given a dictionary with keys as items and values as their prices. You have to print the cheapest item. \n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "A single line non-empty dictionary\n",
    "\n",
    "Sample output:\n",
    "cheapest_item name: cheapest_item_cost\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "{'mobile1':10000, 'mobile2':11000, 'mobile3':13000, 'mobile4':9000, 'mobile5':15000, 'mobile6':16000, 'mobile7':17000, 'mobile8':18000, 'mobile9':19000}\n",
    "\n",
    "Sample output:\n",
    "mobile4: 9000\n",
    "\n",
    "Note: in case of a tie, whichever item came first should be the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "import ast \n",
    "\n",
    "input_dict=ast.literal_eval(input())\n",
    "value=list(input_dict.values())\n",
    "key=list(input_dict.keys())\n",
    "\n",
    "#start writing your code here\n",
    "cheapest=value[0]\n",
    "pos=0\n",
    "for i in value:\n",
    "    if i < cheapest:\n",
    "        cheapest=i\n",
    "\n",
    "for j in input_dict:\n",
    "    if input_dict[j]==cheapest:\n",
    "        print(j+': '+ str(cheapest))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maximum Distance\n",
    "Description\n",
    "You will be given a list of repeated elements. You have to find the maximum distance between two same elements. The answer will be zero if there are no repeated elements.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A non-empty list of integers.\n",
    "\n",
    "Output:\n",
    "A single integer denoting the maximum distance between two same integers.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[1, 2, 3, 2, 5, 1, 2, 4, 6, 2, 7, 8, 6]\n",
    "\n",
    "Sample output:\n",
    "8\n",
    "\n",
    "Explanation:\n",
    "Max distance for 1: 5\n",
    "Max distance for 2: 8\n",
    "Max distance for 3: 0\n",
    "Max distance for 4: 0\n",
    "Max distance for 5: 0\n",
    "Max distance for 6: 4\n",
    "Max distance for 7: 0\n",
    "Max distance for 8: 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been taken for you\n",
    "import ast\n",
    "input_list= ast.literal_eval(input())\n",
    "\n",
    "#start writing your code from here\n",
    "n=len(input_list)\n",
    "\n",
    "def max_dist(arr, n): \n",
    "    h = {} \n",
    "    max_distance = 0\n",
    "    for i in range(n): \n",
    "        if arr[i] not in h.keys(): \n",
    "            h[arr[i]] = i \n",
    "        else: \n",
    "            max_distance = max(max_distance, i-h[arr[i]]) \n",
    "  \n",
    "    return max_distance\n",
    "\n",
    "print(max_dist(input_list,n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vote for Food\n",
    "Description\n",
    "Your team is going for camping and you are taking a vote to decide what food to pack for dinner.\n",
    "Everyone gets a vote and the food item that gets at least one more than half of the votes wins. None of the items wins if nothing gets at least one more than half votes. Assume that every person gets only one vote.\n",
    "The input will contain a list of food items where each occurrence of an item represents one vote. You should print the winning food item as output. If there is no clear winner, print \"NOTA\". \n",
    "\n",
    "Sample Input:\n",
    "[\"pasta\",\"pasta\",\"pasta\",\"pasta\",\"pasta\",\"paratha\",\"paratha\",\"paratha\"]\n",
    "Sample Output:\n",
    "pasta\n",
    "\n",
    "This question was asked in a Data Analyst interview."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "votes = ast.literal_eval(input_str)\n",
    "count={}\n",
    "\n",
    "for i in votes:\n",
    "    if i not in count:\n",
    "        count[i]=1\n",
    "    else:\n",
    "        count[i]=count[i]+1\n",
    "        \n",
    "value=count.values()\n",
    "value_1=sorted(value)\n",
    "#print(value)\n",
    "#print(value_1)\n",
    "\n",
    "        \n",
    "if value_1[0]==value_1[1]:\n",
    "     print(\"NOTA\")\n",
    "else:     \n",
    "    print(max(count.keys()))\n",
    "    \n",
    "        \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "votes = ast.literal_eval(input_str)\n",
    "\n",
    "votes1 = votes\n",
    "\n",
    "def most_common(lst): \n",
    "    return max(set(lst), key=lst.count) \n",
    "m = most_common(votes1) \n",
    "wordfreq = [] \n",
    "for w in votes1: \n",
    "    wordfreq.append(list.count(w)) \n",
    "    if max(wordfreq) > len(wordfreq)/2:\n",
    "        print(m) \n",
    "    else: \n",
    "        print(\"NOTA\")\n",
    "        \n",
    "    \n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Flatten a dictionary\n",
    "Description\n",
    "Consider a nested dictionary as follows:\n",
    "{'Fruit': 1, 'Vegetable': {'Cabbage': 2, 'Cauliflower': 3}, 'Spices': 4}\n",
    "Your task is to flatten a nested dictionary and join the nested keys with the \"_\" character. For the above dictionary, the flattened dictionary would be as follows:\n",
    "{'Fruit': 1, 'Vegetable_Cabbage': 2, 'Vegetable_Cauliflower': 3, 'Spices': 4}\n",
    "\n",
    "The input will have a nested dictionary.\n",
    "The output should have two lists. The first list will have keys and the second list should have values. Both lists should be sorted.\n",
    "Sample Input:\n",
    "{'Fruit': 1, 'Vegetable': {'Cabbage': 2, 'Cauliflower': 3}, 'Spices': 4}\n",
    "Sample Output:\n",
    "['Fruit', 'Spices', 'Vegetable_Cabbage', 'Vegetable_Cauliflower']\n",
    "[1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_dict = dict(ast.literal_eval(input_str))\n",
    "def flatten_dict(d):\n",
    "    def expand(i,j):\n",
    "        if isinstance(j,dict):\n",
    "            return [(i + '_' + a,l) for a,l in flatten_dict(j).items()]\n",
    "        else:\n",
    "            return[(i,j)]\n",
    "        \n",
    "    items= [item for a,l in d.items() for item in expand(a,l)]\n",
    "    \n",
    "    return dict(items)\n",
    "\n",
    "out1=list(flatten_dict(input_dict).keys())\n",
    "out2=list(flatten_dict(input_dict).values())\n",
    "out1.sort()\n",
    "out2.sort()\n",
    "print(out1)\n",
    "print(out2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_dict = dict(ast.literal_eval(input_str))\n",
    "def flatten_dict(d):\n",
    "    def expand(key, value):\n",
    "        if isinstance(value, dict):\n",
    "            return [ (key + '_' + k, v) for k, v in flatten_dict(value).items() ]\n",
    "        else:\n",
    "            return [ (key, value) ]\n",
    "\n",
    "    items = [ item for k, v in d.items() for item in expand(k, v) ]\n",
    "\n",
    "    return dict(items)\n",
    "\n",
    "out1=list(flatten_dict(input_dict).keys())\n",
    "out2=list(flatten_dict(input_dict).values())\n",
    "out1.sort()\n",
    "out2.sort()\n",
    "print(out1)\n",
    "print(out2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Searching Element\n",
    "Description\n",
    "Searching a particular data entry from a big chunk a task you will encounter frequently.  In this question, you will be given a list of integers and a key element that you will have to find in the list. You will return the index or location of the key in the list or -1 if it is not present.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "Two lines of input. The first line contains a list of integers, the second line contains an integer key that you have to find in the list\n",
    "\n",
    "Output:\n",
    "The index of the first occurrence of the key in the provided list, if it is present, and -1 otherwise.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[1, 2, 4, 2, 3, 2, 3, 3, 6, 7]\n",
    "3\n",
    "\n",
    "Sample output:\n",
    "4\n",
    "\n",
    "Explanation:\n",
    "The first occurrence of the key 3 is at index 4.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[1, 2, 3, 4, 5, 6]\n",
    "10\n",
    "\n",
    "Sample output:\n",
    "-1\n",
    "\n",
    "Explanation:\n",
    "Since 10 is not present in the given list, the output is -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast \n",
    "\n",
    "data_list=ast.literal_eval(input())\n",
    "key=int(input())\n",
    "\n",
    "#find the index of the key in data_list here\n",
    "n=len(data_list)\n",
    "index=-1\n",
    "for i in range(0,n):\n",
    "    if data_list[i]==key:\n",
    "        index= i\n",
    "    \n",
    "print(index)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Binary Search\n",
    "Description\n",
    "You heard Sajan talk about a faster search method when the list we have is sorted. This is a much faster approach as the data you will normally deal with will have tens of thousands of entries, having a search algorithm what is faster will save a lot of computation power and will be faster.\n",
    "You can try your code here.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "Two lines of input will be provided. The first line will have a sorted list with no repeated values, while the second line will have a key whose occurrence you have to find in the list.\n",
    "\n",
    "Output:\n",
    "Index of the key in the given list if it is present, else -1.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27]\n",
    "17\n",
    "\n",
    "Sample output:\n",
    "7\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27]\n",
    "1\n",
    "\n",
    "Sample output:\n",
    "-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "import ast\n",
    "sorted_list=ast.literal_eval(input())\n",
    "key=int(input())\n",
    "\n",
    "#find the index of key in list\n",
    "l=0\n",
    "r= len(sorted_list)-1\n",
    "flag=0 #we make this to know if we found the key or no \n",
    "#we will keep its value as 0, and make it 1 when we find key\n",
    "#so that while printing the index we can simply check if we have to print(-1) or no\n",
    "while l<=r:\n",
    "    mid = (l+r)//2\n",
    "    if sorted_list[mid]==key:\n",
    "        print(mid)\n",
    "        flag=1\n",
    "        break\n",
    "    elif sorted_list[mid]>key:\n",
    "        r = mid-1\n",
    "    else:\n",
    "        l = mid+1\n",
    "if flag!=1:\n",
    "    print(-1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rotated List\n",
    "Description\n",
    "To make the question a little more difficult, the sorted list with no repeated values is first 'rotated' and then passed as input. Everything else remains the same.\n",
    "Rotation of list is done by first selecting the pivot around which the list is then rotated. For eg- the sorted list is [10, 20, 30, 40, 50, 60, 70] and the pivot of rotation is index 2 (that is value 30) then the rotated list will look like [40, 50, 60, 70, 10, 20, 30]\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "Two lines of input, the first line contains a rotated list atmost once, and the second line contains a key that you have to find in the list.\n",
    "\n",
    "Note: The list can be rotated about the last element, meaning the list will remain sorted.\n",
    "\n",
    "Output:\n",
    "Index of the key in the rotated list if it is present, else -1.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[15, 16, 17, 18, 11, 12, 13, 14]\n",
    "12\n",
    "\n",
    "Sample output:\n",
    "5\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27]\n",
    "17\n",
    "\n",
    "Sample output:\n",
    "7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#take input on your own\n",
    "import ast\n",
    "data= ast.literal_eval(input())\n",
    "key=int(input())\n",
    "\n",
    "\n",
    "#find key in rotated list\n",
    "\n",
    "def rotated_array(data,key):\n",
    "    l=0\n",
    "    r=len(data)-1\n",
    "    while l<=r:\n",
    "        mid= (l+r)//2\n",
    "        if data[mid]==key:\n",
    "            return mid\n",
    "        elif data[l]<data[mid]:\n",
    "            if key<=data[mid] & key >=data[l]:\n",
    "                r= mid-1\n",
    "            else:\n",
    "                l= mid+1 \n",
    "        elif data[l]>data[mid]:\n",
    "            if key > a[mid] & k<data[r]:\n",
    "                l=mid+1 \n",
    "            else:\n",
    "                r=mid-1 \n",
    "    return -1 \n",
    "    \n",
    "print(rotated_array(data,key))\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Square Root\n",
    "Description\n",
    "You will be given a positive integer n, you have to use binary search and find the square root of n.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A single positive integer n.\n",
    "0<n<=10000\n",
    "\n",
    "Output:\n",
    "The square root of n, accurate up to 4 decimal places.\n",
    "\n",
    "Hint: you may find round() function useful here.v\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "5\n",
    "\n",
    "Sample output:\n",
    "2.2361\n",
    "\n",
    "Explanation:\n",
    "The square root of 5 is 2.236067977..., upon rounding off to 4 decimals, we get 2.2361\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "9\n",
    "\n",
    "Sample output:\n",
    "3.0000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been taken for you\n",
    "\n",
    "n=int(input())\n",
    "\n",
    "#find square root of n here\n",
    "\n",
    "def sq_rt(n):\n",
    "    l=0\n",
    "    r=n \n",
    "    while abs(l-r)>10**-5:\n",
    "        mid=(l+r)/2\n",
    "        if mid**2>n:\n",
    "            r= mid\n",
    "        else:\n",
    "            l= mid\n",
    "    return round(mid,4)\n",
    "    \n",
    "print(\"%.4f\" % sq_rt(n))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input has been taken for you\n",
    "\n",
    "n=int(input())\n",
    "\n",
    "#find square root of n here\n",
    "def squareroot(n):\n",
    "    l=0\n",
    "    r=n\n",
    "    while abs(l-r)>10**-5:\n",
    "        mid = (l+r)/2\n",
    "        if mid**2>n:\n",
    "            r = mid\n",
    "        else:\n",
    "            l = mid\n",
    "    return round(mid,4)\n",
    "\n",
    "print(\"%.4f\" % squareroot(n))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ternary Search\n",
    "Description\n",
    "In the binary search, you kept reducing the search space into half of the previous search space. In this question, can you similarly reduce the search space in one-third of the last space search and write a searching algorithm?\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A non-empty sorted list of unique integers in line one\n",
    "The integer key to be found in line two\n",
    "\n",
    "Output:\n",
    "Index of the element key if it is present in the list, else -1\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27]\n",
    "17\n",
    "\n",
    "Sample output:\n",
    "7\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27]\n",
    "1\n",
    "\n",
    "\n",
    "Sample output:\n",
    "-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "import ast \n",
    "data = ast.literal_eval(input())\n",
    "key=int(input())\n",
    "#start writing your code from here\n",
    "def find(data,key):\n",
    "    l=0\n",
    "    r=len(data)-1\n",
    "    while(l<=r):\n",
    "        mid1=(l+r)//3\n",
    "        mid2 = mid1*2\n",
    "        if key==data[mid1]:\n",
    "            return mid1\n",
    "        elif  key==data[mid2]:\n",
    "            return mid2\n",
    "        elif key<data[mid1]:\n",
    "            r=mid1-1\n",
    "        elif key> data[mid2]:\n",
    "            l=mid1\n",
    "            r=mid2-1\n",
    "        else:\n",
    "            l=mid2+1 \n",
    "    return(-1) \n",
    "    \n",
    "print(find(data,key))\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finding Root\n",
    "Description\n",
    "When finding out square root, you indirectly solved the problem x2=num for x. You can use the same technique to find roots of other complex functions as well. In this problem, you are asked to solve the equation nx+x=0, where n will be a positive input integer.\n",
    "You are to find a solution accurate up to 6 decimal places.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "Positive integer n\n",
    "1<= n <= 1000\n",
    "\n",
    "Output:\n",
    "value of x that satisfies the given equation accurate upto 6 decimal places\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "1\n",
    "\n",
    "Sample output:\n",
    "-1.000000\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "3\n",
    "Sample output:\n",
    "-0.547809\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "7\n",
    "Sample output:\n",
    "-0.431694"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input has been taken for you\n",
    "n=int(input())\n",
    "\n",
    "#start writing your code from here\n",
    "\n",
    "def func(n):\n",
    "    l=-n\n",
    "    r=0 \n",
    "    while abs(l-r)>10**-7:\n",
    "        mid=(l+r)/2\n",
    "        if ((n**mid)+mid)>0:\n",
    "            r= mid\n",
    "        else:\n",
    "            l= mid\n",
    "    return round(mid,6)\n",
    "    \n",
    "print(\"%.6f\" % func(n))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input has been taken for you\n",
    "n=int(input())\n",
    "\n",
    "#start writing your code from here\n",
    "#we define function f(n, x)\n",
    "#this will take in n and x and find n^x+x\n",
    "def f(n,x):\n",
    "    a=n**x\n",
    "    b=a+x\n",
    "    return b\n",
    "\n",
    "#initial search space is from -n to n\n",
    "l=-n\n",
    "r=n\n",
    "# depending on value of f(n,x) we will change our search space\n",
    "mid=(l+r)/2\n",
    "\n",
    "while (abs(l-r)>10**-8) and (f(n,mid)!=0):\n",
    "    mid=(l+r)/2\n",
    "    if f(n,mid)>0: #if f(n,x) > 0 means root lies in the left half\n",
    "        r=mid\n",
    "    elif f(n,mid)<0: #if f(n,x) < 0 means root lies in the right half\n",
    "        l=mid\n",
    "    \n",
    "print('%0.6f' %round(mid, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Search in Valley\n",
    "Description\n",
    "This is another searching problem. The list given will have a valley trend. The valley_list is created by the following steps. A sorted list is cut in two parts, not necessarily equal. The left part is then reversed and put back in place.\n",
    "sorted_list: [1, 2, 3, 4, 6, 7, 8, 11, 13, 14, 15, 16, 17]\n",
    "valley_list will be obtained by cutting this list at 13 and reversing the left half making it [13, 11, 8, 7, 6, 4, 3, 2, 1, 14, 15, 16, 17]. Find the integer key in the given valley list.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "first-line will contain the valley_list and the second line will contain the element key to be found in the list. No repetition of elements in the valley_list.\n",
    "\n",
    "Output:\n",
    "index of the element key in the valley_list if it is present else -1.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[13, 11, 8, 7, 6, 4, 3, 2, 1, 14, 15, 16, 17]\n",
    "8\n",
    "\n",
    "Sample output:\n",
    "2\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "[13, 11, 8, 7, 6, 4, 3, 2, 1, 14, 15, 16, 17]\n",
    "32\n",
    "\n",
    "Sample output:\n",
    "-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "import ast\n",
    "valley_list=ast.literal_eval(input())\n",
    "key=int(input())\n",
    "\n",
    "#start writing your code here\n",
    "def func(valley_list,key):\n",
    "    for i in range(0,len(valley_list)):\n",
    "        if (key==valley_list[i]):\n",
    "           return i\n",
    "    return-1\n",
    "            \n",
    "\n",
    "print(func(valley_list,key))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "import ast\n",
    "valley_list=ast.literal_eval(input())\n",
    "key=int(input())\n",
    "\n",
    "#we will use a similar approach as used in rotated list question\n",
    "# we notice, if we divide the list at middle, one half is in descending order,\n",
    "#we can use same approach as binary search there\n",
    "#other half will have same trend as original valley list\n",
    "#hence we can loop until there is just one element left\n",
    "\n",
    "#start writing your code here\n",
    "def valleysearch(valley_list, key):\n",
    "    l=0\n",
    "    r=len(valley_list)-1\n",
    "    while(l<=r):\n",
    "        \n",
    "        mid=(r+l)//2\n",
    "        \n",
    "        if valley_list[mid]==key:\n",
    "            return mid\n",
    "            \n",
    "        elif valley_list[mid]<=valley_list[l]:\n",
    "            #left half is sorted in descending order\n",
    "            if key<=valley_list[l] and key>valley_list[mid]: #key is in left half\n",
    "                r=mid-1\n",
    "            else:\n",
    "                l=mid+1\n",
    "       \n",
    "        else:\n",
    "            #this means right half is sorted in ascending order\n",
    "            if key<valley_list[mid]:\n",
    "                r=mid-1\n",
    "            else:\n",
    "                l=mid+1\n",
    "    return -1\n",
    "print(valleysearch(valley_list, key))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arithematic Progression\n",
    "Description\n",
    "In mathematics, an arithmetic progression (AP) or arithmetic sequence is a sequence of numbers such that the difference between the consecutive terms is constant. The difference here means the second minus the first. For instance, sequence 5, 7, 9, 11, 13, 15, . . . is an arithmetic progression with common difference of 2.\n",
    "Given any three terms of some random Arithematic progression and an integer key, you have to determine if the key will be present in the Arithematic sequence or no. check out sample input/output for more clarification.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "The first line will contain three comma-separated integers representing three consecutive of some Arithmetic Progression\n",
    "The second line will have the integer key\n",
    "\n",
    "Output:\n",
    "True if the key is a part of that AP, False otherwise\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "9, 11, 13\n",
    "19\n",
    "\n",
    "Sample output:\n",
    "True\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "9, 11, 13\n",
    "20\n",
    "\n",
    "Sample output:\n",
    "False\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "9, 11, 13\n",
    "3\n",
    "\n",
    "Sample output:\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "\n",
    "\n",
    "\n",
    "#start writing your code here\n",
    "\n",
    "import ast\n",
    "data=ast.literal_eval(input())\n",
    "key=int(input())\n",
    "\n",
    "diff=data[1]-data[0]\n",
    "sub=key-data[0]\n",
    "\n",
    "if (abs(sub)%diff)==0:\n",
    "    print('True')\n",
    "else:\n",
    "    print('False')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "int_str=input()\n",
    "int_list=int_str.split(',')\n",
    "a=int(int_list[0])\n",
    "b=int(int_list[1])\n",
    "c=int(int_list[2])\n",
    "key=int(input())\n",
    "\n",
    "#start writing your code here\n",
    "\n",
    "#we first find the common_difference\n",
    "common_difference=b-a\n",
    "#note that integer c is completely redundant here\n",
    "\n",
    "#since we are just adding common_difference to integer a to get whole sequence\n",
    "# or subtracting common_difference from a\n",
    "# we will simply check if the key has same mod with respect to common_difference\n",
    "#as a%common_difference\n",
    "#if yes then key is in AP else it is not \n",
    "\n",
    "if a%common_difference==key%common_difference:\n",
    "    print(True)\n",
    "else:\n",
    "    print(False)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the Built-in Sort Function\n",
    "Description\n",
    "Sort a list of strings according to their length, with the smallest string appearing first.\n",
    "Hint: Use the appropriate ‘key’ in the sorted() function. If two strings are of the same length then their order — as in the original string — should be preserved.\n",
    "\n",
    "Example:\n",
    "Input 1:\n",
    "[‘I’, ‘love’, ‘to’, ‘code’, ‘in’, ‘Python’]\n",
    "Output 1:\n",
    "[‘I’, ‘to’, ‘in’, ‘love’, ‘code’, ‘Python’]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input\n",
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "# Write your code here\n",
    "def length(item):\n",
    "    return len(item)\n",
    "    \n",
    "print(sorted(input_list,key=length))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input\n",
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "# Use the sorted function on the input_list with the key argument set as 'len'\n",
    "output_list = sorted(input_list, key = len)\n",
    "\n",
    "# Output the sorted list\n",
    "print(output_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Custom Sort\n",
    "Description\n",
    "Sort a list of integers basis the remainder they leave when divided by 5 in an ascending order, i.e. the number that leaves a lower remainder when divided by 5 should come before the number which leaves a higher remainder.\n",
    "\n",
    "Hint: Use the appropriate ‘key’ in the sorted() function. If two integers leave the same remainder then their order — as in the original list — should be preserved.\n",
    "\n",
    "Examples:\n",
    "Input 1:\n",
    "[1, 9, 35, 12, 13, 21, 10]\n",
    "Output 1:\n",
    "[35, 10, 1, 21, 12, 13, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input\n",
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "# Write your code here\n",
    "def func(x):\n",
    "    return x%5\n",
    "\n",
    "print(sorted(input_list,key=func))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recursion Factorial\n",
    "Description\n",
    "Earlier you found factorial using loops. Here you have to apply the theory of recursive functions to find the factorial of a positive integer.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A positive integer num.\n",
    "\n",
    "Output:\n",
    "The value of num factorial, num!.\n",
    "\n",
    "Note: 0!=1.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "3\n",
    "\n",
    "Sample output:\n",
    "6\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "5\n",
    "\n",
    "Sample output:\n",
    "120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input here\n",
    "num=int(input())\n",
    "\n",
    "#write the recurssive function to find the factorial of num\n",
    "def factorial(n):\n",
    "    #find and RETURN factorial of num\n",
    "    if n==0:\n",
    "        return 1\n",
    "    else:\n",
    "        prev=factorial(n-1)\n",
    "        final_answer= n*prev\n",
    "        return final_answer\n",
    "    \n",
    "\n",
    "#function ends here\n",
    "\n",
    "print(factorial(num))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print numbers from -n to +n\n",
    "Description\n",
    "You’re given a positive number ‘n’ as an input. Write a recursive program to print all the numbers from -n to +n (including 0)\n",
    "Example:\n",
    "Input 1:\n",
    "3\n",
    "Output 1:\n",
    "-3\n",
    "-2\n",
    "-1\n",
    "0\n",
    "1\n",
    "2\n",
    "3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input\n",
    "n = int(input())\n",
    "\n",
    "def num(n):\n",
    "    if n==0:\n",
    "        print(0)\n",
    "    else:\n",
    "        print(-n)\n",
    "        num(n-1)\n",
    "        print(n)\n",
    "        \n",
    "\n",
    "num(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input\n",
    "n = int(input())\n",
    "\n",
    "# Define your recursive function\n",
    "def rec(n):\n",
    "    \n",
    "# Define the base case when n = 0, i.e. when you reach zero, you can simply come \n",
    "# out of the recursion. Read the rest of the code to understand why we’ve chosen 0\n",
    "# as our base case to end the recursion, and not ‘-n’. Also, notice that the return\n",
    "# type is NULL. This function does not return anything. It just prints corresponding\n",
    "# values for a given argument.\n",
    "    if(n==0):\n",
    "        print(0)\n",
    "        return\n",
    "\n",
    "# Read the next three lines of code and understand exactly what we’ve done. Each \n",
    "# time, you print the value of -n, and use a recursive call for (n-1), until you\n",
    "# encounter zero (base case written above). The first line simply prints the value\n",
    "# of -n and then, recursively calls the same function with (n-1). After this, \n",
    "# my_rec_func(n-1) executes, while my_rec_func(n) remains on hold. So, when the \n",
    "# execution of the function ‘my_rec_func(n-1)’ reaches line 1 (of the following \n",
    "# 3 lines of code), it prints -(n-1) and calls the function with (n-2), and so on. \n",
    "# Then, when you have printed all the negative values and encountered zero, the \n",
    "# function prints 0 corresponding to the base case written above and passes the \n",
    "# control to my_rec_func(1). Finally, the third line starts executing, and recursively,\n",
    "# all the positive values from 1 to n get printed.        \n",
    "    else:\n",
    "        print(-n)\n",
    "        rec(n-1)\n",
    "        print(n)\n",
    "\n",
    "# Call your recursive function for the first time        \n",
    "rec(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recursive Fibonacci\n",
    "Description\n",
    "Earlier you found Fibonacci numbers using loops. In this question, let's try and find it by writing a recursive function. You will be given a positive integer n you have to find the nth Fibonacci number.\n",
    "\n",
    "The Fibonacci series: 1, 1, 2, 3, 5, 8, 13, 21...\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Input:\n",
    "A positive integer n\n",
    "\n",
    "Output:\n",
    "The nth term in Fibonacci series.\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "2\n",
    "\n",
    "Sample output:\n",
    "1\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Sample input:\n",
    "8\n",
    "\n",
    "Sample output: \n",
    "21\n",
    "\n",
    "----------------------------------------------------------------------\n",
    "Note the execution time limit for this problem is less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input taken here\n",
    "n=int(input())\n",
    "\n",
    "#write code for finding nth fibonacci number\n",
    "def fib(n):\n",
    "    if n==1 or n==2:\n",
    "        return 1 \n",
    "    else: \n",
    "        prev_1= fib(n-1)\n",
    "        prev_2= fib(n-2)\n",
    "        last= prev_1+prev_2\n",
    "        return last \n",
    "        \n",
    "print(fib(n))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Weird Function\n",
    "Description\n",
    "In data science, quite often you need to implement research papers and write code according to what's present in those papers. Research papers have a lot of maths involved and you need to implement the maths in code. In this exercise, you're required to implement some maths in code. The problem is as follows:\n",
    "\n",
    "For fixed integers a, b, c, define a weird function F(n) as follows: \n",
    "F(n) = n - c for all n > b \n",
    "F(n) = F(a + F(a + F(a + F(a + n)))) for all n ≤ b. \n",
    " \n",
    "Also, define S(a, b, c) = ∑F(n) where n takes the values 0 till b [in other words, S(a, b, c) = F(0) + F(1) + F(2) + .... F(b-1) + F(b)].\n",
    "\n",
    "The input will be the value of a, b and c. The output should be S(a, b, c). You can define the functions in your own customized way with no restrictions on the number of parameters. For example, you can define the function S which can take additional parameters than a, b and c. Just make sure the code behaves as per the maths.\n",
    " \n",
    "For example, if a = 20, b = 100 and c = 15, then F(0) = 195 and F(2000) = 1985. \n",
    "Therefore, S(20, 100, 15) = 14245\n",
    "\n",
    "\n",
    "Input:\n",
    "3 values separated by a comma\n",
    "a,b,c\n",
    "\n",
    "Output:\n",
    "S(a,b,c)\n",
    "\n",
    "\n",
    "Sample input:\n",
    "20, 100, 15\n",
    "\n",
    "Sample output:\n",
    "14245"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_str = input()\n",
    "input_list = input_str.split(',')\n",
    "\n",
    "a = int(input_list[0])\n",
    "b = int(input_list[1])\n",
    "c = int(input_list[2])\n",
    "\n",
    "# write code here\n",
    "\n",
    "sum = 0\n",
    "\n",
    "def weird_function(a,b,c,n):\n",
    "    #base case\n",
    "    if n>b:\n",
    "        return n-c\n",
    "    #action and recursive calls\n",
    "    #here more than one recurssive calls will be needed\n",
    "    else:\n",
    "        add=weird_function(a,b,c,a+n)\n",
    "        add1=weird_function(a,b,c,a+add)\n",
    "        add2=weird_function(a,b,c,a+add1)\n",
    "        return weird_function(a,b,c,a+add2)\n",
    "\n",
    "def large_sum(a, b, c):\n",
    "    large_sum = 0\n",
    "    for value in range(b+1):\n",
    "        large_sum += weird_function(a, b, c, value)\n",
    "    return large_sum\n",
    "\n",
    "# store the result in the following variable\n",
    "result = large_sum(a, b, c)\n",
    "\n",
    "# print result -- do not change the following code\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recursive Pattern\n",
    "Description\n",
    "Given a positive integer 'n' and another positive integer 'k' (<n),  print the following pattern using recursion.\n",
    "\n",
    "Example:\n",
    "Input 1: n = 12, k = 5\n",
    "Output 2: 12, 7, 2, -3, 2, 7, 12\n",
    "\n",
    "Input 2: n = 10, k =2\n",
    "Output 2: 10, 8, 6, 4, 2, 0, 2, 4, 6, 8, 10\n",
    "\n",
    "Basically, you need to keep decrementing the given value of 'n' by 'k' until you encounter 0 or a negative number, in which case, you need to start incrementing by 'k' until you reach 'n' again.\n",
    "\n",
    "Format:\n",
    "Input: The first line contains the positive integer 'n'. The second line contains the positive integer 'k'.\n",
    "Output: The required pattern as comma-separated-values as shown in the examples above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Reading the inputs\n",
    "n = int(input())\n",
    "k = int(input())\n",
    "\n",
    "# Function\n",
    "def pattern(n,k):\n",
    "    if (n>0):\n",
    "        print(n,sep='',end=', ')\n",
    "        #print( end=', ')\n",
    "        pattern((n-k),k)\n",
    "        print(end=', ')\n",
    "    print(n,end='')\n",
    "\n",
    "pattern(n,k)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reading the input\n",
    "n = int(input())\n",
    "k = int(input())\n",
    "\n",
    "# Define the function\n",
    "def pattern(n, m, k):\n",
    "    \n",
    "    # Base case. If m <= 0, print m and return from the function\n",
    "    if m <= 0:\n",
    "        print(m, end = \", \")\n",
    "        return\n",
    "    \n",
    "    # Print m, call the recursive function with (n, m-k, k), and then print m again\n",
    "    print(m, end = \", \")\n",
    "    pattern(n, m-k, k)\n",
    "    # This conditional statement has been used so that you do not print a comma \n",
    "    # after the last element.\n",
    "    if(n != m):\n",
    "        print(m, end = \", \")\n",
    "    else:\n",
    "        print(m)\n",
    "\n",
    "# Declaring another variable m equal to n\n",
    "m = n\n",
    "\n",
    "# Calling the function with 3 arguments - n, m, and k. The extra m will be used\n",
    "# for recursive calls. The n will be preserved because if you check the output\n",
    "# format, you will see that after the last element, you shouldn't print a comma.\n",
    "# The value of 'n' in the function will be used primarily for that.\n",
    "pattern(n, m, k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating a 3*3 array\n",
    "Description\n",
    "Create a 3*3 array using list_1 = [1,2,3] list_2 = [4,5,6] list_3 = [7,8,9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "list_1 = input_list[0]\n",
    "list_2 = input_list[1]\n",
    "list_3 = input_list[2]\n",
    "\n",
    "import numpy as np\n",
    "array_1 = np.array([list_1,list_2,list_3])\n",
    "\n",
    "print(array_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Element Wise Multiplication\n",
    "Description\n",
    "Perform an element-wise multiplication using list_1 = [2,3,4,5] list_2 = [7,8,9,6] and obtain the output as a list. \n",
    "Hint: Convert the list to an array and after multiplication convert it back to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "list_1 = input_list[0]\n",
    "list_2 = input_list[1]\n",
    "\n",
    "import numpy as np\n",
    "array_1 = np.array(list_1)\n",
    "array_2 = np.array(list_2)\n",
    "array_3 = array_1*array_2\n",
    "\n",
    "print(list(array_3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create NumPy Array\n",
    "Description\n",
    "Given an integer 'x', create an array of size m*n having all integer values equal to 'x'.\n",
    "Hint: Use dtype to specify integer.\n",
    "\n",
    "Format:\n",
    "Input: \n",
    "Line 1: A single integer 'x'\n",
    "Line 2: A single integer 'm' indicating the number of rows\n",
    "Line 3: A single integer 'n' indicating the number of columns\n",
    "Output: An array of size 'm*n' having all the values as 'x'\n",
    "\n",
    "Example:\n",
    "Input 1:\n",
    "1\n",
    "3\n",
    "3\n",
    "Output 1:\n",
    "[[1 1 1]\n",
    " [1 1 1]\n",
    " [1 1 1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input from stdin()\n",
    "\n",
    "int_x = int(lines[0])\n",
    "rows_m = int(lines[1])\n",
    "cols_n = int(lines[2])\n",
    "\n",
    "import numpy as np\n",
    "array_x = np.full((rows_m,cols_n), int_x, dtype=np.int)\n",
    "\n",
    "print(array_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For a video solution of this code, copy-paste the following link in your browser:\n",
    "# https://youtu.be/VeXximV1FVc\n",
    "\n",
    "\n",
    "# Read the input from stdin()\n",
    "import sys\n",
    "lines = sys.stdin.readlines()\n",
    "int_x = int(lines[0])\n",
    "rows_m = int(lines[1])\n",
    "cols_n = int(lines[2])\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# Create an array of m*n with all elements equal to 'x' using the tile() function \n",
    "array_x = np.tile(int_x, (rows_m, cols_n))\n",
    "\n",
    "# Print the created array\n",
    "print(array_x)\n",
    "\n",
    "# Alternatively\n",
    "# Create an array of m*n with all elements equal to '1' using the ones() function\n",
    "# and multiply it by 'x'.\n",
    "array_x = int_x * np.ones((rows_m, cols_n), dtype = np.int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array 'arange' Function\n",
    "Description\n",
    "Create an array of first 10 multiples of 5 using the 'arange' function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "array_multipleof5 = np.arange(5,55,5)\n",
    "\n",
    "print(array_multipleof5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checkerboard Matrix\n",
    "Description\n",
    "Given an even integer ‘n’, create an ‘n*n’ checkerboard matrix with the values 0 and 1, using the tile function.\n",
    " \n",
    "Format:\n",
    "Input: A single even integer 'n'.\n",
    "Output: An 'n*n' NumPy array in checkerboard format.\n",
    "\n",
    "Example:\n",
    "Input 1:\n",
    "2\n",
    "Output 1:\n",
    "[[0 1]\n",
    " [1 0]]\n",
    "Input 2:\n",
    "4\n",
    "Output 2:\n",
    "[[0 1 0 1] \n",
    " [1 0 1 0]\n",
    " [0 1 0 1]\n",
    " [1 0 1 0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "n = int(input())\n",
    "p=int(n/2)\n",
    "import numpy as np\n",
    "array_2=np.array([0,1])\n",
    "array_3=np.array([1,0])\n",
    "array_1=np.tile([array_2,array_3],(p,p))\n",
    "print(array_1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For a video solution of the code, copy-paste the following link in your browser:\n",
    "# https://youtu.be/cak6Y6yN4AU\n",
    "\n",
    "# Read the variable from STDIN\n",
    "n = int(input())\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# Create the smallest unit of a checkerboard matrix\n",
    "x = np.array([[0, 1], [1, 0]])\n",
    "\n",
    "# Create a checkerboard matrix of size n*n using the tile() function. We use n//2 \n",
    "# since the smallest unit of a checkerboard matrix is already of size 2*2. So, for \n",
    "# creating a larger matrix, say, of size 8, we need to replicate it using the tile()\n",
    "# function 4 times as it will then give a matrix of size 8*8.\n",
    "check = np.tile(x, (n//2, n//2))\n",
    "\n",
    "# Print the created matrix\n",
    "print(check)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2D Array\n",
    "Description\n",
    "Create an array using list list_1 = [10,11,12,13] and list_2 = [15,12,13,14] and print the shape and dimension of the array created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "list_1 = input_list[0]\n",
    "list_2 = input_list[1]\n",
    "\n",
    "import numpy as np\n",
    "array_1 = np.array([list_1,list_2])\n",
    "\n",
    "print((array_1.shape))\n",
    "print((array_1.ndim))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2D Array\n",
    "Description\n",
    "From a 2D array extract all the rows of the 2 column.\n",
    "Hint: 2 column will have index value as 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "import numpy as np\n",
    "array_2d =np.array(input_list) \n",
    "\n",
    "print(array_2d[:,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Border Rows and Columns\n",
    "Description\n",
    "Extract all the border rows and columns from a 2-D array.\n",
    "\n",
    "Format:\n",
    "Input: A 2-D Python list\n",
    "Output: Four NumPy arrays - First column of the input array, first row of the input array, last column of the input array, last row of the input array respectively.\n",
    "\n",
    "Example:\n",
    "Input 1:\n",
    "[[11 12 13 14]\n",
    " [21 22 23 24]\n",
    " [31 32 33 34]]\n",
    "Output 1:\n",
    "[11 21 31]\n",
    "[11 12 13 14]\n",
    "[14 24 34]\n",
    "[31 32 33 34]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input list\n",
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# Convert the input list to a NumPy array\n",
    "array_2d =np.array(input_list)\n",
    "\n",
    "# Extract the first column, first row, last column and last row respectively using\n",
    "# appropriate indexing\n",
    "col_first = array_2d[:,0]\n",
    "row_first = array_2d[0,:]\n",
    "col_last = array_2d[:,-1]\n",
    "row_last = array_2d[-1,:]\n",
    "\n",
    "print(col_first)\n",
    "print(row_first)\n",
    "print(col_last)\n",
    "print(row_last)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For a video solution of the code, copy-paste the following link in your browser:\n",
    "# https://youtu.be/ekELUEdT63E\n",
    "\n",
    "# Read the input list\n",
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "import numpy as np\n",
    "\n",
    "# Convert the input list to a NumPy array\n",
    "array_2d =np.array(input_list)\n",
    "\n",
    "# Extract the number of rows and columns of the array\n",
    "rows = len(array_2d[:, 0])\n",
    "cols = len(array_2d[0, :])\n",
    "\n",
    "# Extract the first column, first row, last column and last row respectively using\n",
    "# appropriate indexing\n",
    "col_1 = array_2d[:, 0]\n",
    "row_1 = array_2d[0, :]\n",
    "col_last = array_2d[:, cols-1]\n",
    "row_last = array_2d[rows-1, :]\n",
    "\n",
    "print(col_1)\n",
    "print(row_1)\n",
    "print(col_last)\n",
    "print(row_last)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stack Three Arrays\n",
    "Description\n",
    "Horizontally stack two arrays using hstack, and finally, vertically stack the resultant array with the third array.\n",
    "\n",
    "Example:\n",
    "Input 1:\n",
    "[[1, 2],\n",
    " [5, 6]]\n",
    "\n",
    "[[3, 4],\n",
    " [7, 8]]\n",
    "\n",
    "[[9, 10, 11, 12]]\n",
    "Output 1:\n",
    "[[1 2 3 4]\n",
    " [5 6 7 8]\n",
    " [9 10 11 12]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the input\n",
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "list_1 = input_list[0]\n",
    "list_2 = input_list[1]\n",
    "list_3 = input_list[2]\n",
    "\n",
    "# Import NumPy\n",
    "import numpy as np\n",
    "\n",
    "array_1= np.array(list_1)\n",
    "array_2= np.array(list_2)\n",
    "array_3= np.array(list_3)\n",
    "\n",
    "array_v = np.hstack((array_1,array_2))\n",
    "array_h = np.vstack((array_v,array_3))\n",
    "print(array_h)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For a video solution of the code, copy-paste the following link in your browser:\n",
    "# https://youtu.be/cuKRGMpn4kM\n",
    "\n",
    "# Read the input\n",
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "list_1 = input_list[0]\n",
    "list_2 = input_list[1]\n",
    "list_3 = input_list[2]\n",
    "\n",
    "# Import NumPy\n",
    "import numpy as np\n",
    "\n",
    "# Convert the given lists to NumPy arrays\n",
    "array_1 = np.array(list_1)\n",
    "array_2 = np.array(list_2)\n",
    "array_3 = np.array(list_3)\n",
    "\n",
    "# Horizontally stack the first and second NumPy arrays\n",
    "final_array = np.hstack((array_1, array_2))\n",
    "\n",
    "# Vertically stack the third array with the array obtained by stacking the first\n",
    "# two vertically \n",
    "final_array = np.vstack((final_array, array_3))\n",
    "\n",
    "# Print the final array\n",
    "print(final_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vectorize Numpy\n",
    "Description\n",
    "Given an array, 'array_3' divide each element with 5. \n",
    "Hint: Create a vectorized function, then apply it to the array_3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "list_1 = input_list[0:2]\n",
    "list_2 = input_list[2:4]\n",
    "import numpy as np\n",
    "array_1 = np.array(list_1)\n",
    "array_2 = np.array(list_2)\n",
    "array_3 =np.hstack((array_1,array_2))\n",
    "\n",
    "function = np.vectorize(lambda x:x/5)\n",
    "\n",
    "print(function(array_3))\n",
    "\n",
    "# For a video solution of the code, copy-paste the following link in your browser:\n",
    "# https://youtu.be/wBF5elMmOv8\n",
    "\n",
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "list_1 = input_list[0:2]\n",
    "list_2 = input_list[2:4]\n",
    "import numpy as np\n",
    "array_1 = np.array(list_1)\n",
    "array_2 = np.array(list_2)\n",
    "array_3 =np.hstack((array_1,array_2))\n",
    "\n",
    "function = np.vectorize(lambda x: x/5)\n",
    "\n",
    "print(function(array_3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Linear algebra\n",
    "Description\n",
    "Find the inverse, eigenvalues, eigenvectors, determinants of a given matrix 'array_1'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "list_1 = input_list[0]\n",
    "list_2 = input_list[1]\n",
    "list_3 = input_list[2]\n",
    "\n",
    "import numpy as np\n",
    "array_1 = np.array([list_1,list_2,list_3])\n",
    "eigen = np.linalg.eig(array_1)\n",
    "inv = np.linalg.inv(array_1)\n",
    "det = np.linalg.det(array_1)\n",
    "print(eigen)\n",
    "print(inv)\n",
    "print(det)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "list_1 = input_list[0]\n",
    "list_2 = input_list[1]\n",
    "list_3 = input_list[2]\n",
    "\n",
    "import numpy as np\n",
    "array_1 = np.array([list_1,list_2,list_3])\n",
    "eigen = np.linalg.eig(array_1)\n",
    "inv = np.linalg.inv(array_1)\n",
    "det = np.linalg.det(array_1)\n",
    "print(eigen)\n",
    "print(inv)\n",
    "print(det)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas Series\n",
    "Description\n",
    "Create a series using list = [6,7,8,9,2,3,4,5] and print the output series as the square of each number in the list.\n",
    "Hint: If input series = 1,2,3 the output series should be 1,4,9\n",
    "Hint: First create the series and then using apply and lambda find the output series."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "series_1 = pd.Series([6,7,8,9,2,3,4,5])\n",
    "series_2 = series_1.apply(lambda x: x**2)\n",
    "print(series_1)\n",
    "print(series_2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DataFrames\n",
    "Description\n",
    "Given a dataframe 'df' use the following commands and analyse the result.\n",
    "describe() \n",
    "columns\n",
    "shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/vBDCsoHCytUSLKkLvq851k2b8JOCkF')\n",
    "print(df.describe())\n",
    "print(df.columns)\n",
    "print(df.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Manual Indexing\n",
    "Description\n",
    "Create a panda series that contains the first ‘n’ natural numbers and their respective squares. The first ‘n’ numbers should appear in the index position.\n",
    "Hint: Use manual indexing.\n",
    " \n",
    "Format:\n",
    "Input: A natural number 'n'\n",
    "Output: A pandas series with the first 'n' natural numbers in the index position and their respective squares in the adjacent column.\n",
    "\n",
    "Example:\n",
    "Input 1:\n",
    "4\n",
    "Output 1:\n",
    "1  1 \n",
    "2  4 \n",
    "3  9 \n",
    "4  16 \n",
    "dtype: int64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For a video solution of the code, copy-paste the following link in your browser:\n",
    "# https://youtu.be/frrYX65Kmh0\n",
    "\n",
    "# Read the variable from STDIN\n",
    "n = int(input())\n",
    "\n",
    "import numpy as np \n",
    "import pandas as pd \n",
    "\n",
    "# Create a pandas series having the squares of the first 'n' natural numbers using\n",
    "# the range function and specify the index explicitly from 1 to n, again, using the\n",
    "# range function\n",
    "x = pd.Series(np.array(range(1,n+1))**2, index = range(1,n+1))\n",
    "\n",
    "# Print the created series\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set Index in Dataframe\n",
    "Description\n",
    "Using set_index command set the column 'X' as the index of the dataset and then print the head of the dataset.\n",
    "Hint: Use inplace = False "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/vBDCsoHCytUSLKkLvq851k2b8JOCkF')\n",
    "df_2 = df.set_index('X', inplace=False)\n",
    "print(df_2.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sorting Dataframes\n",
    "Description\n",
    "Sort the dataframe on 'month' and 'day' in ascending order in the dataframe 'df'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/vBDCsoHCytUSLKkLvq851k2b8JOCkF')\n",
    "df_2 = df.sort_values(by=['month','day'] , ascending=True)\n",
    "print(df_2.head(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing Dataframes\n",
    "Description\n",
    "Print only the even numbers of rows of the dataframe 'df'.\n",
    "\n",
    "Note: Don't include the row indexed zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/vBDCsoHCytUSLKkLvq851k2b8JOCkF')\n",
    "df_2 = df[2::2]\n",
    "print(df_2.head(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selecting Columns of a Dataframe\n",
    "Description\n",
    "Print out the columns 'month', 'day', 'temp', 'area' from the dataframe 'df'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/vBDCsoHCytUSLKkLvq851k2b8JOCkF')\n",
    "df_2 = df[['month','day','temp','area']]\n",
    "print(df_2.head(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataframe iloc\n",
    "Description\n",
    "Using iloc index the dataframe to print all the rows of the columns at index 3,4,5.\n",
    "Hint: Use 3,4,5 not 2,3,4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/vBDCsoHCytUSLKkLvq851k2b8JOCkF')\n",
    "df_2 = df.iloc[ :,[3,4,5]]\n",
    "print(df_2.head(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataframes loc\n",
    "Description\n",
    "Using loc function print out all the columns and rows from 2 to 20 of the 'df' dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/vBDCsoHCytUSLKkLvq851k2b8JOCkF')\n",
    "df_2 = df.loc[2:20,:]\n",
    "print(df_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Applying Conditions on Dataframes\n",
    "Description\n",
    "Print all the columns and the rows where 'area' is greater than 0, 'wind' is greater than 1 and the 'temp' is greater than 15."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/vBDCsoHCytUSLKkLvq851k2b8JOCkF')\n",
    "df_2 = df.loc[(df.area > 0) & (df.wind > 1) & (df.temp >15), :]\n",
    "print(df_2.head(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataframes Merge\n",
    "Description\n",
    "Perform an inner merge on two data frames df_1 and df_2 on  'unique_id' and print the combined dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df_1 = pd.read_csv('https://query.data.world/s/vv3snq28bp0TJq2ggCdxGOghEQKPZo')\n",
    "df_2 = pd.read_csv('https://query.data.world/s/9wVKjNT0yiRc3YbVJaiI8a6HGl2d74')\n",
    "df_3 = pd.merge(df_1,df_2, how='inner' , on='unique_id')\n",
    "print(df_3.head(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataframe Append\n",
    "Description\n",
    "Append two datasets df_1 and df_2, and print the combined dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df_1 = pd.read_csv('https://query.data.world/s/vv3snq28bp0TJq2ggCdxGOghEQKPZo')\n",
    "df_2 = pd.read_csv('https://query.data.world/s/9wVKjNT0yiRc3YbVJaiI8a6HGl2d74')\n",
    "df_3 =pd.concat([df_1,df_2])\n",
    "print(df_3.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operations on multiple dataframes\n",
    "Description\n",
    "Given three data frames containing the number of gold, silver, and bronze Olympic medals won by some countries, determine the total number of medals won by each country. \n",
    "Note: All the three data frames don’t have all the same countries. So, ensure you use the ‘fill_value’ argument (set it to zero), to avoid getting NaN values. Also, ensure you sort the final dataframe, according to the total medal count in descending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import pandas as pd\n",
    "\n",
    "# Defining the three dataframes indicating the gold, silver, and bronze medal counts\n",
    "# of different countries\n",
    "gold = pd.DataFrame({'Country': ['USA', 'France', 'Russia'],\n",
    "                         'Medals': [15, 13, 9]}\n",
    "                    )\n",
    "silver = pd.DataFrame({'Country': ['USA', 'Germany', 'Russia'],\n",
    "                        'Medals': [29, 20, 16]}\n",
    "                    )\n",
    "bronze = pd.DataFrame({'Country': ['France', 'USA', 'UK'],\n",
    "                        'Medals': [40, 28, 27]}\n",
    "                    )\n",
    "gold.set_index('Country', inplace=True)\n",
    "silver.set_index('Country' ,inplace=True)\n",
    "bronze.set_index('Country', inplace=True)\n",
    "\n",
    "total= gold.add(silver, fill_value=0)\n",
    "total_1=total.add(bronze, fill_value=0)\n",
    "total_1.sort_values(by = (['Medals']), ascending = False)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataframe grouping\n",
    "Description\n",
    "Group the data 'df' by 'month' and 'day' and find the mean value for column 'rain' and 'wind'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/vBDCsoHCytUSLKkLvq851k2b8JOCkF')\n",
    "df_2= df.groupby(['month','day'])\n",
    "df_2\n",
    "df_1 = df_2['rain','wind'].mean()\n",
    "print(df_1.head(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating New Column in a Dataframe\n",
    "Description\n",
    "Create a new column 'XY' which consist of values obtained from multiplying column 'X' and column 'Y'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/vBDCsoHCytUSLKkLvq851k2b8JOCkF')\n",
    "df['XY'] =df['X']*df['Y']\n",
    "print(df.head(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataframe Pivot Table\n",
    "Description\n",
    "Group the data 'df' by 'month' and 'day' and find the mean value for column 'rain' and 'wind' using the pivot table command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/vBDCsoHCytUSLKkLvq851k2b8JOCkF')\n",
    "df_1 = df.pivot_table(values = ['rain','wind'], index = ['month','day'], aggfunc = 'mean')\n",
    "print(df_1.head(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Missing Values\n",
    "Description\n",
    "Print out the number of missing values in each column in the given dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/Hfu_PsEuD1Z_yJHmGaxWTxvkz7W_b0')\n",
    "print(df.isnull().sum(axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Missing Values Percentage\n",
    "Description\n",
    "Find out the percentage of missing values in each column in the given dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/Hfu_PsEuD1Z_yJHmGaxWTxvkz7W_b0')\n",
    "print(round(100*(df.isnull().sum()/len(df.index)), 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Removing Missing Values From the Rows\n",
    "Description\n",
    "Remove the rows having greater than 5 missing values and then print the percentage of missing values in each column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/Hfu_PsEuD1Z_yJHmGaxWTxvkz7W_b0')\n",
    "df1 = df[df.isnull().sum(axis=1) <= 5]\n",
    "print(round(100*(df1.isnull().sum()/len(df.index)), 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Mean Imputation\n",
    "Description\n",
    "Impute the mean value at all the missing values of the column 'Product_Base_Margin' and then print the percentage of missing values in each column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "df = pd.read_csv('https://query.data.world/s/Hfu_PsEuD1Z_yJHmGaxWTxvkz7W_b0')\n",
    "#Type your code here for mean imputation\n",
    "df1=df.loc[:, ['Product_Base_Margin']].describe()\n",
    "df.loc[pd.isnull(df['Product_Base_Margin']), ['Product_Base_Margin']] = df1.iloc[1,0]\n",
    "print(round(100*(df.isnull().sum()/len(df.index)), 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Swap two rows\n",
    "Description\n",
    "Given m and n, swap the mth and nth rows of the 2-D NumPy array given below.\n",
    "\n",
    "a = [[4 3 1]\n",
    "         [5 7 0]\n",
    "         [9 9 3]\n",
    "         [8 2 4]]\n",
    "\n",
    "Example:\n",
    "Input 1:\n",
    "0\n",
    "2\n",
    "Output 1:\n",
    "[[9 9 3] \n",
    " [5 7 0] \n",
    " [4 3 1] \n",
    " [8 2 4]] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "\n",
    "# Given array\n",
    "a = np.array([[4, 3, 1], [5, 7, 0], [9, 9, 3], [8, 2, 4]])\n",
    "\n",
    "# Read the values of m and n\n",
    "import sys\n",
    "lines = sys.stdin.readlines()\n",
    "m = int(lines[0])\n",
    "n = int(lines[1])\n",
    "\n",
    "# Write your code for swapping here\n",
    "a[[m, n]] = a[[n, m]]\n",
    "\n",
    "# Print the array after swapping\n",
    "print(a)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create border array\n",
    "Description\n",
    "Given a single integer n, create an (n x n) 2D array with 1 on the border and 0 on the inside.\n",
    "\n",
    "Note: Make sure the array is of type int.\n",
    "\n",
    "Example:\n",
    "Input 1:\n",
    "4\n",
    "Output 1:\n",
    "[[1 1 1 1]\n",
    "[1 0 0 1]\n",
    "[1 0 0 1]\n",
    "[1 1 1 1]]\n",
    "Input 2:\n",
    "2\n",
    "Output 2:\n",
    "[[1 1] \n",
    " [1 1]] \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the variable from STDIN\n",
    "n = int(input())\n",
    "\n",
    "import numpy as np\n",
    "n_n= np.ones((n,n), dtype = np.int)\n",
    "#print(n_n)\n",
    "\n",
    "n_n[1:-1,1:-1]=0\n",
    "\n",
    "print(n_n)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Odd or Even\n",
    "Write a python program to check if a number entered is odd or even. The input will contain one positive integer n.\n",
    "Print “Odd” if the number is odd and “Even” if the number is even.\n",
    "Sample Input:\n",
    "2\n",
    "Sample Output:\n",
    "Even"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "if n%2==0:\n",
    "     print(\"Even\")\n",
    "else:\n",
    "     print(\"Odd\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sub-lists containing a given element\n",
    "Write Python code to print the number of sub-lists in a list, containing a given element.\n",
    "Hint: You could use list comprehensions to avoid lengthy code\n",
    "\n",
    "Sample Input:\n",
    "[[\"mumbai\",\"pune\",\"goa\"], [\"goa\",\"mumbai\", \"satara\"], [1, 3, 5, 7, 9]]\n",
    "1\n",
    "Sample output:\n",
    "1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "inputList = input_list[0]#The list\n",
    "n = input_list[1]#The element to look for\n",
    "print(sum(n in subList for subList in inputList) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unique values\n",
    "Write Python code to find all unique values in a given list of key-value pairs.\n",
    "The input would be a list of key-value pairs and you have to print the number of unique values as output.\n",
    "Note: 'Roses' and 'roses' will be treated as different values.\n",
    "Sample Input:\n",
    "[{'garden1':'Roses'},{'garden2':'Lilies'},{'garden3':'Roses'},{'garden4':'Mangoes'}]\n",
    "Sample Output:\n",
    "3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_dict = ast.literal_eval(input_str)\n",
    "uniqueVals = set( val for dic in input_dict for val in dic.values())#converting into a set since a set stores only unique values\n",
    "print(len(uniqueVals))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Divisibility\n",
    "Consider that m,n,x and y are four positive integers.\n",
    "Your task is to find all integers between m and n(including m and n) that are divisible by x and y.\n",
    "The input will contain four lines with m,n,x and y in the same order. The output should contain the number of positive integers divisible by x and y between m and n.\n",
    "Sample Input:\n",
    "1\n",
    "6\n",
    "2\n",
    "3\n",
    "Sample Output:\n",
    "1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "m = input_list[0]\n",
    "n = input_list[1]\n",
    "x = input_list[2]\n",
    "y = input_list[3]\n",
    "count=0\n",
    "for i in range(m,n+1):\n",
    "    if (i%x==0) & (i%y==0):\n",
    "        count=count+1\n",
    "print(count)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Armstrong Number\n",
    "Any number, say n is called an Armstrong number if it is equal to the sum of its digits, where each is raised to the power of number of digits in n.\n",
    "For example:\n",
    "153=13+53+33\n",
    "\n",
    "Write Python code to determine whether an entered three digit number is an Armstrong number or not. \n",
    "Assume that the number entered will strictly be a three digit number.\n",
    "Print \"True\" if it is an Armstrong number and print \"False\" if it is not.\n",
    "Sample Input:\n",
    "153\n",
    "Sample Output:\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "digits=list(map(int,str(n)))\n",
    "num=sum(list(map(lambda x:x**3,digits)))\n",
    "print(num==n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "sum=0\n",
    "temp = n\n",
    "while temp > 0:\n",
    "   digit = temp % 10\n",
    "   sum += digit ** 3\n",
    "   temp //= 10\n",
    "if n == sum:\n",
    "   print('True')\n",
    "else:\n",
    "   print('False')\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fibonacci Series\n",
    "Compute and display Fibonacci series upto n where n is a positive integer entered by the user.\n",
    "You can go here to read about Fibonacci series.\n",
    "Sample Input:\n",
    "5\n",
    "Sample Output:\n",
    "0\n",
    "1\n",
    "1\n",
    "2\n",
    "3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "#write your code here\n",
    "#res = [x if x<=1 else for x in range(0,5)]\n",
    "res = []\n",
    "num_1 = 0\n",
    "num_2 = 1\n",
    "for num in range(0,n+1):\n",
    "    if num<=1:\n",
    "        res.append(num)\n",
    "    elif num>1 and len(res)<n:\n",
    "        num = res[num-1] + res[num-2]\n",
    "        res.append(num)\n",
    "print(*res, sep = \"\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "#write your code here\n",
    "n1=0\n",
    "n2=1\n",
    "sm=0\n",
    "for i in range(0,n):\n",
    "    print(n1)\n",
    "    sm=n1+n2\n",
    "    n1=n2\n",
    "    n2=sm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prime Numbers\n",
    "Determine whether a positive integer n is a prime number or not. Assume n>1.\n",
    "Display “number entered is prime” if n is prime, otherwise display “number entered is not prime”.\n",
    "Sample Input:\n",
    "7\n",
    "Sample Output:\n",
    "number entered is prime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "out=True\n",
    "for i in range(2,n):\n",
    "    if(n%i==0):\n",
    "        out=False\n",
    "        break\n",
    "if out==True:\n",
    "    print(\"number entered is prime\")\n",
    "else:\n",
    "    print(\"number entered is not prime\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "#write your code here\n",
    "\n",
    "for i in range(2,n+1):\n",
    "    count=0\n",
    "    for j in range(2,i):\n",
    "        if (i%j==0):\n",
    "            count=count+1\n",
    "\n",
    "        \n",
    "if count==0:\n",
    "    print('number entered is prime')\n",
    "else:\n",
    "    print('number entered is not prime')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selecting dataframe columns\n",
    "Write a program to select all columns of a dataframe except the ones specified.\n",
    "The input will contain a list of columns that you should skip.\n",
    "You should print the first five rows of the dataframe as output where the columns are alphabetically sorted.\n",
    "\n",
    "Note that when you are printing anything, use the print command and not directly (like the jupyter notebook)\n",
    "Sample Input:\n",
    "['PassengerId', 'Pclass', 'Name', 'Sex','Embarked']\n",
    "Sample Output:\n",
    "        Age Cabin     Fare  Parch  SibSp   Ticket\n",
    "0  34.5   NaN   7.8292      0      0   330911\n",
    "1  47.0   NaN   7.0000      0      1   363272\n",
    "2  62.0   NaN   9.6875      0      0   240276\n",
    "3  27.0   NaN   8.6625      0      0   315154\n",
    "4  22.0   NaN  12.2875      1      1  3101298\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import ast,sys\n",
    "df=pd.read_csv(\"https://media-doselect.s3.amazonaws.com/generic/X0kvr3wEYXRzONE5W37xWWYYA/test.csv\")\n",
    "pd.set_option('display.max_columns', 500)\n",
    "input_str = sys.stdin.read()\n",
    "to_omit = ast.literal_eval(input_str)\n",
    "\n",
    "df=df[df.columns[~df.columns.isin(to_omit)]]\n",
    "print(df.loc[:, sorted(list(df.columns))].head())\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equal arrays\n",
    "Write python code to check if two given numpy arrays have the same values and size.\n",
    "i.e. the arrays can have same elements but in different orders.\n",
    "Print \"Equal\" if the arrays have same elements and size otherwise print \"Not equal\".\n",
    "Note: The array would contain only numeric data.\n",
    "Sample Input:\n",
    "[0,1,2,3,4]\n",
    "[4,3,1,2,0]\n",
    "Sample Output:\n",
    "Equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "import numpy as np\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "array1 = np.array(input_list[0])\n",
    "array2= np.array(input_list[1])\n",
    "array1.sort()\n",
    "array2.sort()\n",
    "if np.array_equal(array1,array2):\n",
    "    print(\"Equal\")\n",
    "else:\n",
    "    print(\"Not equal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nearest value\n",
    "Description\n",
    "Given a numpy array, you have to find the closest value to n where n is a real number entered by the user.\n",
    "Note: You can assume that the input wouldn't be such that there are two equally close values to it in the array.\n",
    "Sample Input:\n",
    "[1,2,3,4,5,6,7,8,9]\n",
    "2.75\n",
    "Sample Output:\n",
    "3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "import numpy as np\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "array=np.array(input_list[0])\n",
    "n=input_list[1]\n",
    "print(array[(np.abs(array-n)).argmin()])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even Numbers\n",
    "Description\n",
    "From a given list, remove all even numbers(including 0) and print out the resulting list.\n",
    "\n",
    "Sample Input:\n",
    "\n",
    "[2, 3, 5, 8, 1, 2, 7, 3, 9, 0, 3, 1]\n",
    "\n",
    "Sample Output:\n",
    "\n",
    "[3, 5, 1, 7, 3, 9, 3, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "import numpy as np\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "print([x for x in input_list if x%2!=0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings and numbers\n",
    "Description\n",
    "Given a string s, you have to find the count of numbers(0-9) and alphabets(a-z, A-Z) in it. \n",
    "Note: In the string \"str1ngs.num\", there are 9 alphabets and 1 number. You can ignore the '.' or any other characters other than 0-9, a-z or A-Z.\n",
    "The input will contain a string s. The first line of output should contain the count of numbers in the string and the second line should contain number of alphabets in the string.\n",
    "Sample Input:\n",
    "Aab23c$1\n",
    "Sample output:\n",
    "3\n",
    "4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=input()\n",
    "count_alpha=0\n",
    "count_num=0\n",
    "for character in s:\n",
    "    if character.isalpha():\n",
    "        count_alpha=count_alpha+1\n",
    "    if character.isdigit():\n",
    "        count_num=count_num+1\n",
    "print(count_num)\n",
    "print(count_alpha)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String-swap case\n",
    "Description\n",
    "Given a string containing both lowercase and uppercase alphabets, your task is to swap the case of each letter.\n",
    "\n",
    "Sample Input:\n",
    "IaMAkShay\n",
    "\n",
    "Sample Output:\n",
    "iAmaKsHAY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string=input()\n",
    "print(string.swapcase())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Local Maxima\n",
    "Description\n",
    "Given a list, your job is to find values which are surrounded by smaller values on both sides. Such a value is called a local maxima.\n",
    "For example, 3(at index 1) is a local maxima\n",
    " in the given series:\n",
    "[1,3,2,4]\n",
    "Input format:\n",
    "The input will be a list of numbers\n",
    "Output Format:\n",
    "Output should be a list of indices local maximas in the list in increasing sorted order.\n",
    "Hint: You can convert it into a numpy/pandas series to use the inbuilt functions from pandas and numpy.\n",
    "\n",
    "Sample Input:\n",
    "[3,8,99,9,7,4,3,77,0,2,3,4,5]\n",
    "Sample Output:\n",
    "[2,7]\n",
    "\n",
    "Note: There are multiple ways to do this. Try to choose a method other than using simple loops and comparisons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "import numpy as np\n",
    "from scipy.signal import argrelextrema\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "arr=np.asarray(input_list)\n",
    "maximas=argrelextrema(arr, np.greater)\n",
    "maximas = [item for x in maximas for item in x]\n",
    "#maximas=[int(x) for x in maximas] #do not change this code, the output should be an integer list for evaluation purposes\n",
    "print(maximas)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "import numpy as np\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "diffArray=np.diff(np.sign(np.diff(input_list)))\n",
    "maximas=list(np.where(diffArray == -2)[0] + 1)\n",
    "maximas=[int(x) for x in maximas]\n",
    "print(maximas)\n",
    "#below is an alternate approach\n",
    "#from scipy.signal import argrelextrema\n",
    "#maximas=argrelextrema(ser.values, np.greater)[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exchanging columns\n",
    "Description\n",
    "Given two column names, you have to interchange the indices (positions) of the columns in a dataframe.\n",
    "The input will have names of two columns and the output should have first three rows of the dataframe.\n",
    "Note: You can try running the code first in a Jupyter notebook before submitting it here.\n",
    "Sample Input:\n",
    "Sex\n",
    "Name\n",
    "Sample Output:\n",
    "\n",
    "   PassengerId  Pclass     Sex                              Name   Age  SibSp  \\\n",
    "0          892       3    male                  Kelly, Mr. James  34.5      0   \n",
    "1          893       3  female  Wilkes, Mrs. James (Ellen Needs)  47.0      1   \n",
    "2          894       2    male         Myles, Mr. Thomas Francis  62.0      0   \n",
    "\n",
    "   Parch  Ticket    Fare Cabin Embarked  \n",
    "0      0  330911  7.8292   NaN        Q  \n",
    "1      0  363272  7.0000   NaN        S  \n",
    "2      0  240276  9.6875   NaN        Q  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "pd.set_option('display.max_columns', 500)\n",
    "df=pd.read_csv(\"https://media-doselect.s3.amazonaws.com/generic/BgyRrKq0xex8B0N3GJxbXv5WZ/test.csv\")\n",
    "col1=input()\n",
    "col2=input()\n",
    "col_list=list(df.columns)\n",
    "col_list[df.columns.get_loc(col1)],col_list[df.columns.get_loc(col2)]=col_list[df.columns.get_loc(col2)],col_list[df.columns.get_loc(col1)]\n",
    "print(df[col_list].head(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataframe from lists\n",
    "Description\n",
    "You are given a list where the first sub-list contains the column name and the following sub-lists each represent a row.\n",
    "Create a pandas dataframe using this list and print summary stats (df.describe()) for the resultant dataframe.\n",
    "Note that the first sub-list will have column names.\n",
    "Note: Data type of all columns should stay as int.\n",
    "Sample Input:\n",
    "[['c1','c2','c3'],[1,2,3],[4,5,6],[7,8,9]]\n",
    "Sample Output:\n",
    "\n",
    "        c1   c2   c3\n",
    "count  3.0  3.0  3.0\n",
    "mean   4.0  5.0  6.0\n",
    "std    3.0  3.0  3.0\n",
    "min    1.0  2.0  3.0\n",
    "25%    2.5  3.5  4.5\n",
    "50%    4.0  5.0  6.0\n",
    "75%    5.5  6.5  7.5\n",
    "max    7.0  8.0  9.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import sys,ast\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "cols=input_list.pop(0)\n",
    "df = pd.DataFrame(input_list, columns = cols)\n",
    "print(df.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Case-insensitive) Longest substring\n",
    "Description\n",
    "Given a string, you have to find the longest substring in alphabetical order where the string can have both lowercase and uppercase characters i.e. 'Ab' can be considered to be in alphabetical order.\n",
    "\n",
    "Note: If there are two such substrings then you should print the substring starting at a lower index. (For example: in the string \"abcbaefb\", you should print \"abc\".\n",
    "\n",
    "Sample Input:\n",
    "AbCddfsdf\n",
    "Sample Output:\n",
    "AbCddfs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string=input()\n",
    "prevChar = \"\"\n",
    "curr_longest = \"\"\n",
    "longest = \"\"\n",
    "\n",
    "for char in string:\n",
    "    if (prevChar.lower()<=char.lower()):\n",
    "        curr_longest += char\n",
    "        if len(curr_longest) > len(longest):\n",
    "            longest= curr_longest\n",
    "    else:\n",
    "        curr_longest = char\n",
    "    prevChar = char\n",
    "print( longest )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find group\n",
    "Description\n",
    "Given a dataframe, you have to group it by given column name(list of column names). After that, you should print data of the group with a specified column value(values).  The input will contain two lines. First-line will have a list of columns and second will have a list of values. The output should have the first five rows of the corresponding group. (there can be less than five rows in a group too)\n",
    "\n",
    "Please use the 'print' command to print the dataframe.\n",
    "\n",
    "Consider the dataframe below:\n",
    "\n",
    "   PassengerId  Pclass                                          Name     Sex  \\\n",
    "0          892       3                              Kelly, Mr. James    male   \n",
    "1          893       3              Wilkes, Mrs. James (Ellen Needs)  female   \n",
    "2          894       2                     Myles, Mr. Thomas Francis    male   \n",
    "3          895       3                              Wirz, Mr. Albert    male   \n",
    "4          896       3  Hirvonen, Mrs. Alexander (Helga E Lindqvist)  female   \n",
    "\n",
    "    Age  SibSp  Parch   Ticket     Fare Cabin Embarked  \n",
    "0  34.5      0      0   330911   7.8292   NaN        Q  \n",
    "1  47.0      1      0   363272   7.0000   NaN        S  \n",
    "2  62.0      0      0   240276   9.6875   NaN        Q  \n",
    "3  27.0      0      0   315154   8.6625   NaN        S  \n",
    "4  22.0      1      1  3101298  12.2875   NaN        S  \n",
    "\n",
    "\n",
    "For example, consider the below sample input:\n",
    "['Pclass','Age']\n",
    "[3,13]\n",
    "\n",
    "You will first group the given dataframe by Pclass and Age. Then you will find the group where Pclass=3 and Age=13. The output would be as follows:\n",
    "\n",
    "     PassengerId  Pclass                           Name   Sex   Age  SibSp  \\\n",
    "154         1046       3   Asplund, Master. Filip Oscar  male  13.0      4   \n",
    "392         1284       3  Abbott, Master. Eugene Joseph  male  13.0      0   \n",
    "\n",
    "     Parch     Ticket     Fare Cabin Embarked  \n",
    "154      2     347077  31.3875   NaN        S  \n",
    "392      2  C.A. 2673  20.2500   NaN        S  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "pd.set_option('display.max_columns', 500)\n",
    "import sys,ast\n",
    "df=pd.read_csv('https://media-doselect.s3.amazonaws.com/generic/wkyk2AWYdJbqgXoRo3Y8w42nX/test.csv')\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "cols=input_list[0]#the columns to group the dataframe by\n",
    "values=input_list[1]# The group to print\n",
    "#Write your code here\n",
    "data=df.groupby(cols)\n",
    "d1=df[(df[cols[0]]==values[0]) & (df[cols[1]]==values[1])]\n",
    "print(d1.head())\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "pd.set_option('display.max_columns', 500)\n",
    "import sys,ast\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "cols=input_list[0]\n",
    "values=input_list[1]\n",
    "df=pd.read_csv('https://media-doselect.s3.amazonaws.com/generic/wkyk2AWYdJbqgXoRo3Y8w42nX/test.csv')\n",
    "print(df.groupby(cols).get_group(tuple(values)).head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two series\n",
    "Description\n",
    "Given two pandas series, find the position of elements in series2 in series1.\n",
    "You can assume that all elements in series2 will be present in series1.\n",
    "The input will contain two lines with series1 and series2 respectively.\n",
    "The output should be a list of indexes indicating elements of series2 in series 1.\n",
    "Note: In the output list, the indexes should be in ascending order.\n",
    "Sample Input:\n",
    "[1,2,3,4,5,6,7]\n",
    "[1,3,7]\n",
    "Sample Output:\n",
    "[0,2,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "import pandas as pd\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "series1=pd.Series(input_list[0])\n",
    "series2=pd.Series(input_list[1])\n",
    "out_list=[pd.Index(series1).get_loc(num) for num in series2]\n",
    "print(list(map(int,out_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse the dataframe\n",
    "Description\n",
    "Write Python code to reverse the rows of a given dataframe.\n",
    "The input will contain the URL of a dataframe and a number n.\n",
    "The output should contain first n rows of the dataframe.\n",
    "\n",
    "Sample Input:\n",
    "https://media-doselect.s3.amazonaws.com/generic/o8oEby20V1LLAZzpABwWa7R1n/heart.csv\n",
    "4\n",
    "Sample output:\n",
    "\n",
    "     age  sex  cp  trestbps  chol  fbs  restecg  thalach  exang  oldpeak  \\\n",
    "302   57    0   1       130   236    0        0      174      0      0.0   \n",
    "301   57    1   0       130   131    0        1      115      1      1.2   \n",
    "300   68    1   0       144   193    1        1      141      0      3.4   \n",
    "299   45    1   3       110   264    0        1      132      0      1.2   \n",
    "\n",
    "     slope  ca  thal  target  \n",
    "302      1   1     2       0  \n",
    "301      1   1     3       0  \n",
    "300      1   2     3       0  \n",
    "299      1   0     3       0  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "url=input()\n",
    "n=int(input())\n",
    "df=pd.read_csv(url)\n",
    "pd.set_option('display.max_columns', 500)\n",
    "print(df.loc[df.index[::-1], :].head(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data Cleaning-I\n",
    "Description\n",
    "Given a dataframe, you have to do the following:\n",
    "Delete rows with more than 50 percent missing values\n",
    "Remove ‘-’ character from the ‘Date’ column\n",
    "Round off all float columns to two decimal places\n",
    "Input Format:\n",
    "The input will only contain the url of a dataframe to be cleaned.\n",
    "Output format:\n",
    "The first line should contain number of rows in the final dataframe\n",
    "The second line should contain number of columns in the final dataframe\n",
    "The third line onwards, you should print first 10 values of the ‘date’ column\n",
    "After the dates column, you should print first 5 rows with only the float columns\n",
    "Note: You can refer to the sample testcase for a sample dataframe URL and sample output. You can try the code on your own Jupyter notebook before submitting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "url=input()\n",
    "df=pd.read_csv(url)\n",
    "df = df.loc[:, df.isin([' ','NULL',0]).mean() < .5]\n",
    "df = df.dropna(axis = 0, thresh=(df.shape[1])/2)\n",
    "df.Date=df.Date.str.replace(\"-\", \"\")\n",
    "floats = ['float32', 'float64']\n",
    "colsToRound=df.select_dtypes(include=floats).columns\n",
    "colsToRound=df[colsToRound].round(decimals=2)\n",
    "print(df.shape[0])\n",
    "print(df.shape[1])\n",
    "print(df.Date.head(10))\n",
    "print(colsToRound.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pascal's Triangle\n",
    "Description\n",
    "A pascal's triangle is a very interesting mathematical concept.\n",
    "Each number here is a sum of the two numbers directly above it.\n",
    "Following is an 8 level Pascal's triangle:﻿\n",
    "﻿\n",
    "You can read about the Pascal's triangle here.\n",
    "Your task is to print an n level Pascal's triangle.\n",
    "The input will contain an integer n.\n",
    "The output will contain n lines. Each ith line will have a list of numbers representing the ith row of the Pascal's triangle.\n",
    "\n",
    "Sample Input:\n",
    "6\n",
    "Sample Output:\n",
    "\n",
    "[1]\n",
    "[1, 1]\n",
    "[1, 2, 1]\n",
    "[1, 3, 3, 1]\n",
    "[1, 4, 6, 4, 1]\n",
    "[1, 5, 10, 10, 5, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "\n",
    "def binomialCoeff(n, k) : \n",
    "    coeff = 1\n",
    "    if (k > n - k) : \n",
    "        k = n - k \n",
    "    for i in range(0 , k) : \n",
    "        coeff = coeff * (n - i) \n",
    "        coeff = coeff // (i + 1) \n",
    "\n",
    "    return coeff\n",
    "for line in range(0, n) : \n",
    "    current_row=[]\n",
    "    for i in range(0, line + 1) : \n",
    "        current_row.append(binomialCoeff(line, i))\n",
    "    print(current_row) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normalize columns\n",
    "Description\n",
    "Given a dataframe, you have to normalise given columns in it.\n",
    "To normalise a set of values xi , You can use the following formula:﻿\n",
    "﻿\n",
    "Here, xmin and xmax indicate the maximum and minimum values of the series x.\n",
    "The input will contain a list of column names. You should normalise the column values. The output should contain df.describe() dataframe.\n",
    "Note: You can assume that the column names in the input list would strictly be numeric columns.\n",
    "Sample Input:\n",
    "['Serial No.', 'GRE Score', 'TOEFL Score']\n",
    "\n",
    "Sample Output:\n",
    "\n",
    "       Serial No.   GRE Score  TOEFL Score  University Rating         SOP  \\\n",
    "count   400.00000  400.000000   400.000000         400.000000  400.000000   \n",
    "mean      0.50000    0.536150     0.550357           3.087500    3.400000   \n",
    "std       0.28976    0.229473     0.216768           1.143728    1.006869   \n",
    "min       0.00000    0.000000     0.000000           1.000000    1.000000   \n",
    "25%       0.25000    0.360000     0.392857           2.000000    2.500000   \n",
    "50%       0.50000    0.540000     0.535714           3.000000    3.500000   \n",
    "75%       0.75000    0.700000     0.714286           4.000000    4.000000   \n",
    "max       1.00000    1.000000     1.000000           5.000000    5.000000   \n",
    "\n",
    "             LOR         CGPA    Research  Chance of Admit   \n",
    "count  400.000000  400.000000  400.000000        400.000000  \n",
    "mean     3.452500    8.598925    0.547500          0.724350  \n",
    "std      0.898478    0.596317    0.498362          0.142609  \n",
    "min      1.000000    6.800000    0.000000          0.340000  \n",
    "25%      3.000000    8.170000    0.000000          0.640000  \n",
    "50%      3.500000    8.610000    1.000000          0.730000  \n",
    "75%      4.000000    9.062500    1.000000          0.830000  \n",
    "max      5.000000    9.920000    1.000000          0.970000  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "pd.set_option('display.max_columns', 500)\n",
    "import sys,ast\n",
    "input_str = sys.stdin.read()\n",
    "colsToNormalize = ast.literal_eval(input_str)\n",
    "df=pd.read_csv(\"https://media-doselect.s3.amazonaws.com/generic/GVj4YrNpJwOvL7gBe2B53wJy/Admission_Predict.csv\")\n",
    "df[colsToNormalize] = df[colsToNormalize].apply(lambda x: (x - x.min()) / (x.max() - x.min()))\n",
    "print(df.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data Cleaning-II\n",
    "Description\n",
    "In the given dataset, you have to do the following:\n",
    "Remove rows with more than 2 missing values\n",
    "Remove any column having the same value for all rows\n",
    "Normalize all numerical columns(check for integer and float columns) \n",
    "Determine invalid values in the 'Year' column(assume every input dataframe will have an year column and an invalid year would be more than 2018 and less than 1900). Remember to calculate this before normalizing columns since Year will be a numeric column\n",
    "Note: you simply have to determine invalid values and not delete the\n",
    "        5. Drop duplicate rows\n",
    "Input format:\n",
    "The input will only contain the URL of a csv file. The import statement has been written for you in the stub\n",
    "Output format:\n",
    "The first line will have number of invalid values in the year column\n",
    "The second line will have the number of rows in the resulting dataframe\n",
    "The third line will have number of columns in the resulting dataframe\n",
    "The fourth line will have first three rows of the resulting dataframe\n",
    "\n",
    "Note: You can refer to the sample testcase for a sample dataframe URL and sample output. You can try the code on your own Jupyter notebook before submitting.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "pd.set_option('display.max_columns', 500)\n",
    "import numpy as np \n",
    "url=input()\n",
    "df=pd.read_csv(url)\n",
    "\n",
    "#printing the number of invalid values in the year column\n",
    "df_1=df[(df['Year']>2018) | (df['Year']<1900)]\n",
    "no_rows=list(df_1.shape)\n",
    "print(no_rows[0])\n",
    "\n",
    "#printing now of rows \n",
    "no_rows=list(df.shape)\n",
    "print(no_rows[0])\n",
    "\n",
    "#Remove rows with more than 2 missing values\n",
    "df_2= df[df.isnull().sum(axis=1) < 2]\n",
    "\n",
    "#Remove any column having the same value for all rows\n",
    "nunique = df.apply(pd.Series.nunique)\n",
    "cols_to_drop = nunique[nunique == 1].index\n",
    "df_3=df.drop(cols_to_drop, axis=1)\n",
    "no_rows=list(df_3.shape)\n",
    "print(no_rows[1])\n",
    "\n",
    "#check for integer and float columns\n",
    "df_4=df_3.select_dtypes(include =['int64','float64']) \n",
    "colsToNormalize=list(df_4.columns)\n",
    "\n",
    "#colsToNormalize\n",
    "df_3[colsToNormalize] = df_3[colsToNormalize].apply(lambda x:(x-x.min()) / (x.max()-x.min()))\n",
    "print(df_3.head(3))\n",
    "\n",
    "df.drop_duplicates()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "pd.set_option('display.max_columns', 500)\n",
    "import numpy as np \n",
    "url=input()\n",
    "df=pd.read_csv(url)\n",
    "df = df[df.isnull().sum(axis=1) < 3] #removing rows with more than 2 missing values\n",
    "for col in list(df.columns):  #Deleting columns with same value for all rows\n",
    "    if df[col].drop_duplicates().shape[0]==1:\n",
    "        df=df.drop(col,axis=1)\n",
    "print(df[(df.Year<1900)|(df.Year>=2019)].shape[0])#invalid values in Year column\n",
    "numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64'] #normalization\n",
    "colsToNormalize=df.select_dtypes(include=numerics).columns\n",
    "df[colsToNormalize] = df[colsToNormalize].apply(lambda x: (x - x.min()) / (x.max() - x.min()))\n",
    "df=df.drop_duplicates()#drop duplicate rows\n",
    "print(df.shape[0])\n",
    "print(df.shape[1])\n",
    "print(df.head(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Longest substring\n",
    "Description\n",
    "Given a string, find the longest consecutive substring containing only alphabets.\n",
    "You can assume that the string will have at least one alphabet.\n",
    "Note: If there are two such substrings then you should print the substring starting at a lower index. (For example: in the string \"here123were23we\", you should print \"here\".\n",
    "\n",
    "Sample Input:\n",
    "hello25my34name is 34567CzechosLovakia\n",
    "\n",
    "Sample Output:\n",
    "CzechosLovakia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string=input()\n",
    "longest = '' \n",
    "i = 0\n",
    "while(i<len(string)): \n",
    "\n",
    "    curr_longest = '' \n",
    "\n",
    "    # For letter substring  \n",
    "    while(i<len(string) and string[i].isalpha()): \n",
    "        curr_longest += string[i] \n",
    "        i+= 1\n",
    "\n",
    "    if(len(curr_longest) > len(longest) ): \n",
    "        longest = curr_longest\n",
    "    i+=1\n",
    "\n",
    "print(longest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String strip\n",
    "Description\n",
    "Write a Python program to strip a given of characters from a string.\n",
    "Hint: you can use inbuilt functions here.\n",
    "The input will contain two lines. The first line will contain a string and the second line will contain a list of characters to remove from the string.\n",
    "Sample Input:\n",
    "Hello.students@upgrad\n",
    "['.','@']\n",
    "Sample Output:\n",
    "Hellostudentsupgrad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys,ast\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "string=input_list[0]\n",
    "to_strip=input_list[1]\n",
    "for char in to_strip:\n",
    "    string=string.replace(char,\"\")\n",
    "print(string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cracking the code\n",
    "Description\n",
    "In a computer, all information is stored as 0s and 1s. This is called the binary format.\n",
    "You can read more about binary numbers here.\n",
    "Assume that you are a detective trying to bust a local mafia gang. You intercept a computer in their base receiving various lists of binary codes.\n",
    "Every day the mafia gang has a new code. If the list of binary codes has a number n occurring m times, then it indicates that a shipment of weapons is about to reach their base.\n",
    "The values of m and n are given to you daily as decimal numbers by an undercover detective in the mafia gang. Your job is to identify if a shipment is arriving and alert your teams.\n",
    "\n",
    "Note that the list of binary codes will have to be converted into decimal numbers or m and n will have to be converted into binary numbers for you to check if the list has m times n.\n",
    "Print \"Shipment arriving, let's bust 'em!\" if you find the occurrence of n, m number of times in the list. Otherwise, print \"No shipment, false alarm.\".\n",
    "Input Format:\n",
    "The first line will contain a list of binary codes as strings and the next two lines will contain the integers m and n respectively.\n",
    "Sample Input:\n",
    "['1101','1010','1101','1101']\n",
    "3\n",
    "13\n",
    "Sample Output:\n",
    "Shipment arriving, let's bust 'em!\n",
    "\n",
    "Hint: You can find Python built in functions that will help you to convert data from binary to decimal and vice-versa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "inputList = input_list[0]\n",
    "m = input_list[1]\n",
    "n=input_list[2]\n",
    "convertedList=list(map(lambda x: int(x,2), inputList))\n",
    "if convertedList.count(n)==m:\n",
    "    print (\"Shipment arriving, let's bust 'em!\")\n",
    "else:\n",
    "    print (\"No shipment, false alarm.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Filter Rows\n",
    "Description\n",
    "Given a dataframe, you have to find rows which contain a given keyword in a column and print the number of such rows.\n",
    "The first line of input will contain the column name and the second line will contain the keyword to look for.\n",
    "Note: Do df.dropna() before proceeding with string match\n",
    "Sample Input:\n",
    "Translated_Review\n",
    "Great\n",
    "\n",
    "Sample Output:\n",
    "1681"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "col=input()\n",
    "to_match=input()\n",
    "df=pd.read_csv(\"https://media-doselect.s3.amazonaws.com/generic/LByRZAyOeazLyp8R7QnX5Ez2e/googleplaystore_user_reviews.csv\")\n",
    "df=df.dropna()\n",
    "print(df[df[col].str.contains(to_match)].shape[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "n values\n",
    "Description\n",
    "Find the n smallest and largest values in a given column in a dataframe.\n",
    "The input will contain two lines where first line will contain the positive integer n and the second line will contain a column name.\n",
    "The first line should contain a list of n smallest values of the given column and the second line should contain a list of n largest values.\n",
    "Note: The first list should have values in ascending order and the second should have values in descending order.\n",
    "Hint: You can find an inbuilt Python function to find n smallest/largest values.\n",
    "Sample Input:\n",
    "5\n",
    "PassengerId\n",
    "Sample Output:\n",
    "[892, 893, 894, 895, 896]\n",
    "[1309, 1308, 1307, 1306, 1305]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "df=pd.read_csv(\"https://media-doselect.s3.amazonaws.com/generic/w1M5ZNB22P0pK4JXVAV18n58/test.csv\")\n",
    "n=int(input())\n",
    "col=input()\n",
    "print(list(df.nsmallest(n, [col])[col].values))\n",
    "print(list(df.nlargest(n, [col])[col].values))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sum of Primes\n",
    "Description\n",
    "Write python code to find the sum of prime numbers from 2 to n where n is a positive integer entered by the user.\n",
    "Note: n can be non-prime or prime. You have to find sum of primes till n and not sum of n prime numbers. i.e. for input 10, output should be 17.\n",
    "Hint: You can try using lambda functions and comprehensions to reduce the lines of code you have to write.\n",
    "Sample Input:\n",
    "5\n",
    "Sample Output:\n",
    "10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "num=int(input())\n",
    "\n",
    "sm=0\n",
    "for i in range(2,num+1):\n",
    "    count=0\n",
    "    for j in range(2,i):\n",
    "        if (i%j==0):\n",
    "            count=count+1\n",
    "    if count==0:\n",
    "        sm=sm+i\n",
    "        \n",
    "print(sm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "n=int(input())\n",
    "print(sum(num for num in range(2,n+1)if all(num%i!=0 for i in range(2,int(math.sqrt(num))+1))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Palindrome Permutation\n",
    "Description\n",
    "Given a string, you have to find if a permutation of its characters forms a palindrome.\n",
    "For example: 'civic'\n",
    "Print\"Yes\" if forming a palindrome is possible otherwise print \"No\"\n",
    "Sample input:\n",
    "iiccv\n",
    "Sample Output:\n",
    "Yes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter \n",
    "string=input()\n",
    "\n",
    "\n",
    "def any_palindrome(myString):\n",
    "    counts = Counter(myString)\n",
    "    number_of_odd = sum(1 for letter, cnt in counts.items() if cnt%2)\n",
    "    return number_of_odd <= 1\n",
    "\n",
    "result=any_palindrome(string)\n",
    "\n",
    "if result==False:\n",
    "    print(\"No\")\n",
    "else:\n",
    "    print(\"Yes\")\n",
    "    \n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string=input()\n",
    "from collections import Counter \n",
    "res = Counter(string) \n",
    "count=0\n",
    "for key in res:\n",
    "    if (res[key]%2!=0) & (count==1):\n",
    "        count=2\n",
    "        break\n",
    "    if (res[key]%2!=0) & (count==0):\n",
    "        count=1\n",
    "if(count>1):\n",
    "    print('No')\n",
    "else:\n",
    "    print('Yes')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gambling 101\n",
    "You are participating in a lottery game. A deck of cards numbered from 1-50 is shuffled and 5 cards are drawn out and laid out. You are given a coin. For each card, you toss the coin and pick it up if it says heads, otherwise you don't pick it up. The sum of the cards is what you win.\n",
    "The lottery ticket costs c rupees. If the expected value of the sum of cards you pick up is less than the lottery ticket, then you buy another ticket otherwise you don't.\n",
    "\n",
    "Input Format:\n",
    "The first 5 lines of the input will contain 5 numbers between 1 to 50.\n",
    "The next line will contain c, the cost of lottery ticket.\n",
    "Output Format:\n",
    "Print \"Don't buy another\" if the expected value is less than the ticket price and print \"Buy another one\" if the expected value is more than the ticket price.\n",
    "\n",
    "Sample Input:\n",
    "1\n",
    "4\n",
    "6\n",
    "17\n",
    "3\n",
    "23\n",
    "Sample Output:\n",
    "Don't buy another\n",
    "\n",
    "Note: You have to take input using the input() function. For your practice with taking inputs, the stub will be empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum=0\n",
    "for i in range(0,5):\n",
    "    sum=sum+int(input())/2\n",
    "if sum<=int(input()):\n",
    "    print(\"Don't buy another\")\n",
    "else:\n",
    "    print(\"Buy another one\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generating normal distribution\n",
    "Generate an array of real numbers representing a normal distribution. You will be given the mean and standard deviation as input. You have to generate 10 such numbers.\n",
    "Hint: You can use numpy's np.random here.  You can read more about it here.\n",
    "To keep the output consistent, you have to set the seed as a specific number which will be given to you as input. Setting a seed means that every time you generate random numbers, they will be the same for the same seed. You can read more about it here.\n",
    "\n",
    "Input Format:\n",
    "The input will contain 3 lines which have the seed, mean and standard deviation of the distribution in the same order.\n",
    "The output will be a numpy array of the generated normal distribution.\n",
    "\n",
    "Sample Input:\n",
    "1\n",
    "0\n",
    "0.1\n",
    "\n",
    "Sample Output:[ 0.16243454 -0.06117564 -0.05281718 -0.10729686  0.08654076 -0.23015387\n",
    "  0.17448118 -0.07612069  0.03190391 -0.02493704]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "seed=int(input())\n",
    "mean=float(input())\n",
    "std_dev=float(input())\n",
    "np.random.seed(seed)\n",
    "s = np.random.normal(mean, std_dev, 10)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Confidence Intervals\n",
    "For a given column in a dataframe, you have to calculate the 90 percent confidence interval for its mean value. (You can find Z* value for 90 percent confidence from previous segments)\n",
    "The input will have the column name. \n",
    "The output should have the confidence interval printed as a tuple.\n",
    "Note: Do not use the inbuilt function via statmodels.api or any other libraries. You should write the code on your own to get accurate answers.\n",
    "The confidence interval values have to be approximated up to two decimal places.\n",
    "Sample Input:\n",
    "GRE Score\n",
    "\n",
    "Sample Output:\n",
    "(315.87, 317.75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import numpy as np\n",
    "df=pd.read_csv(\"https://media-doselect.s3.amazonaws.com/generic/N9LKLvBAx1y14PLoBdL0yRn3/Admission_Predict.csv\")\n",
    "col=input()\n",
    "mean = df[col].mean()\n",
    "sd = df[col].std()\n",
    "n = len(df)\n",
    "Zstar=1.65\n",
    "se = sd/np.sqrt(n)\n",
    "lcb = mean - Zstar * se\n",
    "ucb = mean + Zstar * se\n",
    "print((round(lcb,2),round(ucb,2)))\n",
    "\n",
    "#via statmodels.api you can do this as follows:\n",
    "#import statsmodels.api as sm\n",
    "#sm.stats.DescrStatsW(df[col]).zconfint_mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "College admissions\n",
    "The probability that a college will accept a student's application is x.\n",
    "Consider that m students have applied to college. You have to find the probability that at most n students are accepted by the college.\n",
    "The input will contain three lines with x, m and n respectively.\n",
    "The output should be rounded off to four decimal places.\n",
    "Sample Input:\n",
    "0.3\n",
    "5\n",
    "2\n",
    "Sample Output:\n",
    "0.8369"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats as ss\n",
    "x=float(input())\n",
    "m=int(input())\n",
    "n=int(input())\n",
    "dist=ss.binom(m,x)\n",
    "sum=0.0\n",
    "for i in range(0,n+1):\n",
    "    sum=sum+dist.pmf(i)\n",
    "print(round(sum,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tossing a coin\n",
    "Given that you are tossing a coin n times, you have to find the probability of getting heads at most m times.\n",
    "The input will have two lines containing n and m respectively.\n",
    "Sample Input:\n",
    "10\n",
    "2\n",
    "Sample Output:\n",
    "0.0547"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats as ss\n",
    "n=int(input())#number of trials\n",
    "m=int(input())# find the probability of getting at most m heads\n",
    "dist=ss.binom(n,0.5)\n",
    "sum=0.0\n",
    "for i in range(0,m+1):\n",
    "    sum=sum+dist.pmf(i)\n",
    "print(round(sum,4))\n",
    "#you can also use the following\n",
    "#round(dist.cdf(m),2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combination Theory\n",
    "You are given a list of n natural numbers. You select m numbers from the list at random. \n",
    "Find the probability that at least one of the selected alphabets is \"x\" where x is a number given to you as input.\n",
    "The first line of input will contain a list of numbers. The second line will contain m and the third line will contain x.\n",
    "The output should be printed out as float.\n",
    "Sample Input:\n",
    "[1,2,3,4,5,6,6,6,6,7,7,7]\n",
    "3\n",
    "6\n",
    "Sample Output:\n",
    "0.7454545454545455"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "nums=input_list[0]\n",
    "m=int(input_list[1])#m numbers are chosen\n",
    "x=int(input_list[2])#find probability of getting at least one x \n",
    "from itertools import combinations \n",
    "num = 0\n",
    "den = 0\n",
    "for c in combinations(nums,m):\n",
    "    den=den+1\n",
    "    if x in c:\n",
    "        num=num+1\n",
    "    \n",
    "print (float(num)/den)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rolling the dice\n",
    "A die is rolled n times. You have to find the probability that a number i is rolled at least j times(up to four decimal places)\n",
    "The input will contain the integers n, i and j in three lines respectively. You can assume that j<n and 0<i<7.\n",
    "The output should be rounded off to four decimal places.\n",
    "Sample Input:\n",
    "4\n",
    "1\n",
    "2\n",
    "Sample Output:\n",
    "0.1319"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats as ss\n",
    "n=int(input())\n",
    "i=int(input())\n",
    "j=int(input())\n",
    "dist=ss.binom(n,1/6)\n",
    "print(round(1-dist.cdf(j-1),4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lego Stack\n",
    "You are given a row of Lego Blocks consisting of n blocks. All the blocks given have a square base whose side length is known. You need to stack the blocks over each other and create a vertical tower. Block-1 can go over Block-2 only if sideLength(Block-2)>sideLength(Block-1).\n",
    "From the row of Lego blocks, you on only pick up either the leftmost or rightmost block.\n",
    "Print \"Possible\" if it is possible to stack all n cubes this way or else print \"Impossible\".\n",
    "\n",
    "Input Format:\n",
    "The input will contain a list of n integers representing the side length of each block's base in the row starting from the leftmost.\n",
    "\n",
    "Sample Input:\n",
    "[5 ,4, 2, 1, 4 ,5]\n",
    "Sample Output:\n",
    "Possible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "sides = ast.literal_eval(input_str)#list of side lengths\n",
    "l=len(sides)\n",
    "diff = [(sides[i]-sides[i+1]) for i in range(l-1)]\n",
    "i = 0 \n",
    "while (i<l-1 and diff[i]>=0) : i += 1 \n",
    "while (i<l-1 and diff[i]<=0) : i += 1\n",
    "if (i==l-1) : print(\"Possible\") \n",
    "else : print(\"Impossible\")\n",
    "\n",
    "#to understand the code, try printing out all intermediate variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generating Binomial Distribution\n",
    "Description\n",
    "Generate a binomial distribution, tested 10 times, given the number of trials(n) and probability(p) of each trial.\n",
    "\n",
    "The input will contain seed, n and p in the same order.\n",
    "\n",
    "The output should contain a numpy array with 10 numbers representing the required binomial distribution.\n",
    "\n",
    "Hint: You can use numpy's random number generator here too. Remember to set the seed before generating numbers to ensure correct output.\n",
    "\n",
    "Sample Input:\n",
    "\n",
    "0\n",
    "\n",
    "10\n",
    "\n",
    "0.5\n",
    "\n",
    "Sample Output:\n",
    "\n",
    "\n",
    "\n",
    "[5 6 5 5 5 6 5 7 8 5]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "seed=int(input())\n",
    "n=int(input())\n",
    "p=float(input())\n",
    "np.random.seed(seed)\n",
    "s = np.random.binomial(n, p, 10)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Coloured cards\n",
    "Description\n",
    "A card stack contains white and black cards. Two cards are drawn randomly without replacement. The probability of selecting a white and then a black card is x. The probability of selecting a white card in the first draw is y. You have to find the probability of drawing a black card, given that the first card drawn was white.\n",
    "The input will contain two lines with x and y respectively.  \n",
    "The output should be displayed as a float(no need to round it off).\n",
    "Sample Input:\n",
    "0.2\n",
    "0.5\n",
    "Sample Output:\n",
    "0.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=float(input())\n",
    "y=float(input())\n",
    "#write your code here\n",
    "print(x/y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entrance Test\n",
    "Description\n",
    "Consider that the scores of an entrance test are normally distributed. \n",
    "If the test has a mean of m and a standard deviation of s.\n",
    "You have set the cut off as 90 marks for the test. What is the probability of a student passing the test?\n",
    "The input will contain m and s in two lines in the same order. The output has to be rounded off to two decimal places.\n",
    "Sample Input:\n",
    "100\n",
    "10\n",
    "Sample Output:\n",
    "0.84"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats\n",
    "m=float(input())#mean\n",
    "sd=float(input())#standard deviation\n",
    "print(round(1-scipy.stats.norm(m,sd).cdf(90),2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Symmetric triangle\n",
    "Description\n",
    "A symmetric triangle of level 5 would look as follows:\n",
    "\n",
    "1\n",
    "121\n",
    "12321\n",
    "1234321\n",
    "123454321\n",
    "\n",
    "As you can see, each row here is a palindrome. Your task is to print an n level symmetric triangle.\n",
    "Note: There should be no spaces between the numbers in the triangle.\n",
    "\n",
    "Sample Input:\n",
    "4\n",
    "Sample Output:\n",
    "\n",
    "1\n",
    "121\n",
    "12321\n",
    "1234321"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "def palindrome(num):\n",
    "    for i in range(1, num + 1):\n",
    "        print(int('1' * i)**2)\n",
    "        \n",
    "\n",
    "palindrome(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "current=1\n",
    "for i in range(1,n+1):\n",
    "    print(current**2)\n",
    "    current=current*10+1;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seating Arrangement\n",
    "Description\n",
    "N people sit around a circular table. You have to find the probability that two particular people won't be sitting together.\n",
    "\n",
    "\n",
    "\n",
    "The input will have the number N and the output should have the probability printed as a float type number rounded off to four decimal places.\n",
    "\n",
    "\n",
    "\n",
    "Hint: This problem follows the logic of circular permutation which you can read about here.\n",
    "\n",
    "Sample Input:\n",
    "\n",
    "15\n",
    "\n",
    "\n",
    "\n",
    "Sample Output:\n",
    "\n",
    "0.8571\n",
    "\n",
    "\n",
    "Sample input:\n",
    "\n",
    "5\n",
    "\n",
    "\n",
    "\n",
    "Sample output:\n",
    "\n",
    "0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "probability= (n-3)/(n-1)\n",
    "print(round(probability,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=int(input())\n",
    "#first we find the number of permutation of making all n people sit in a circle\n",
    "#this will be n!/n = (n-1)!\n",
    "\n",
    "#now we find number of permutations when two people will always be together\n",
    "#this will be [(n-1)!/(n-1)] * 2 = (n-2)! * 2 \n",
    "\n",
    "#so total number of acceptable permutations will be (n-1)! - ((n-2)! * 2)\n",
    "\n",
    "#hence answer will be above expression divided by (n-1)!\n",
    "\n",
    "answer=1 - (2/(n-1))\n",
    "\n",
    "\n",
    "print(round(answer,4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Valid customer IDs\n",
    "Simon runs a pharmaceutical factory. Only customers who have been pre-approved can enter the manufacturing facility and do a quality check for their order.\n",
    "The pre-approved customers get a customer ID which needs to be validated at entrance. \n",
    "A valid customer ID:\n",
    "-It will have groups of three characters separated by \"_\".\n",
    "-Can only contain numbers 0-9 and characters a-z and A-Z.(other than \"_\")\n",
    "-Contains 12 characters excluding the \"_\"\n",
    "-A character cannot be repeated more than thrice.\n",
    "\n",
    "You have to write Python code to check for valid customer IDs.\n",
    "The input will have a customer ID and the output should say \"valid\" if the entered ID is valid otherwise it should say \"invalid\".\n",
    "\n",
    "Sample Input:\n",
    "abc_123_2ac_Adf\n",
    "\n",
    "Sample Output:\n",
    "valid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validitycheck(cid):\n",
    "    #req1: a-z and 0-9 only \n",
    "    if not (cid.replace(\"_\",\"\").isalnum()):\n",
    "        return (\"invalid\")\n",
    "    #req2 & 3 :4 groups, each group has three characters with a-z, A-Z and 0-9\n",
    "    groups=cid.split(\"_\")\n",
    "    if len(groups)>4:\n",
    "        return (\"invalid\")\n",
    "    for group in groups:\n",
    "        if len(group)>3:\n",
    "            return (\"invalid\")\n",
    "    \n",
    "    #Req 5: repeating characters check\n",
    "    from collections import Counter\n",
    "    counts=dict(Counter(cid))\n",
    "    for key in counts.keys():\n",
    "        if counts.get(key)>3:\n",
    "            return(\"invalid\")\n",
    "    return(\"valid\")\n",
    "    \n",
    "cid=input()\n",
    "print(validitycheck(cid))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Password Validation\n",
    "Your company requires employees to set a strong password for their email accounts.\n",
    "The characteristics of a strong password include:\n",
    "1. it should be at least 8 characters long\n",
    "2. it should have one lowercase alphabet.\n",
    "3.it should have one uppercase alphabet\n",
    "4. it should have at least one number(0-9)\n",
    "5. it should have one special character( a special character is considered among the following: [@%$*])\n",
    "If the input is a valid password then print \"valid\" or else print \"invalid\".\n",
    "\n",
    "Sample input:\n",
    "DataScience123\n",
    "Sample Output:\n",
    "Invalid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pwd=input()\n",
    "import re\n",
    "if ((len(pwd)>=8) and (re.search(\"[a-z]\",pwd)) and (re.search(\"[A-Z]\",pwd)) and (re.search(\"[0-9]\",pwd)) and (re.search(\"[@%$*]\",pwd))):\n",
    "    print(\"Valid\")\n",
    "else:\n",
    "    print(\"Invalid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Divide the dataframe\n",
    "Write a Python program to slice a dataframe in a given ratio.\n",
    "For example: if the dataframe has 160 rows and you have to slice it in a ratio of 1:3, then the first part will have the first 40 rows(0-39) and the second part will have the next 120 rows(40-159).\n",
    "The input will have two lines with the ratio to separate the dataframe in. For example, for 1:3, the input will be as follows:\n",
    "1\n",
    "3\n",
    "The output should contain the summary statistics(df.describe()) of both resulting dataframes in the respective order.\n",
    "Note: You can assume that the given ratio will split the dataframe exactly into two non-fractional parts.\n",
    "Sample Input:\n",
    "10\n",
    "30\n",
    "Sample Output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "df=pd.read_csv(\"https://media-doselect.s3.amazonaws.com/generic/A0zOxQvk78ONwRgLZ1WYJOxWq/titaniMod2.csv\")\n",
    "a=int(input())\n",
    "b=int(input())\n",
    "c=int(a/(a+b)*len(df))\n",
    "print(df[:c].describe())\n",
    "print(df[c:].describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Flatten a dictionary\n",
    "Consider a nested dictionary as follows:\n",
    "{'Fruit': 1, 'Vegetable': {'Cabbage': 2, 'Cauliflower': 3}, 'Spices': 4}\n",
    "Your task is to flatten a nested dictionary and join the nested keys with the \"_\" character. For the above dictionary, the flattened dictionary would be as follows:\n",
    "{'Fruit': 1, 'Vegetable_Cabbage': 2, 'Vegetable_Cauliflower': 3, 'Spices': 4}\n",
    "\n",
    "The input will have a nested dictionary.\n",
    "The output should have two lists. The first list will have keys and the second list should have values. Both lists should be sorted.\n",
    "Sample Input:\n",
    "{'Fruit': 1, 'Vegetable': {'Cabbage': 2, 'Cauliflower': 3}, 'Spices': 4}\n",
    "Sample Output:['Fruit', 'Spices', 'Vegetable_Cabbage', 'Vegetable_Cauliflower']\n",
    "[1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_dict = dict(ast.literal_eval(input_str))\n",
    "def flatten_dict(d):\n",
    "    def expand(key, value):\n",
    "        if isinstance(value, dict):\n",
    "            return [ (key + '_' + k, v) for k, v in flatten_dict(value).items() ]\n",
    "        else:\n",
    "            return [ (key, value) ]\n",
    "\n",
    "    items = [ item for k, v in d.items() for item in expand(k, v) ]\n",
    "\n",
    "    return dict(items)\n",
    "\n",
    "out1=list(flatten_dict(input_dict).keys())\n",
    "out2=list(flatten_dict(input_dict).values())\n",
    "out1.sort()\n",
    "out2.sort()\n",
    "print(out1)\n",
    "print(out2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2-Sample t-test\n",
    "Perform 2-sample t-tests on given columns of the dataframe.\n",
    "The input will contain the names of two columns to test in two lines and the output should have the p-value obtained from the paired two sample tests.\n",
    "Sample Input:\n",
    "city-mpg\n",
    "highway-mpg\n",
    "Sample Output:\n",
    "1.9665445899143185e-113"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import scipy.stats\n",
    "df=pd.read_csv(\"https://media-doselect.s3.amazonaws.com/generic/K9WgyRZ75q4Pkdp38AQabgE0X/Automobile_data.csv\")\n",
    "col1=input()\n",
    "col2=input()\n",
    "print(scipy.stats.ttest_rel(df[col1],df[col2]).pvalue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "t-test on a column\n",
    "Perform a t-test on a given column of a given data frame. \n",
    "The input will contain the column name and the value of x, the mean value to test in two lines respectively. The output should contain the p-value obtained.\n",
    "Sample Input:\n",
    "CGPA\n",
    "8\n",
    "Sample Output:\n",
    "1.6070878523226457e-62"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import scipy.stats\n",
    "df=pd.read_csv(\"https://media-doselect.s3.amazonaws.com/generic/5J7nrZegVWOORbGr4M7KVPXE5/Admission_Predict.csv\")\n",
    "col=input()\n",
    "x=float(input())\n",
    "print(scipy.stats.ttest_1samp(df[col], x).pvalue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List Overlap\n",
    "Write Python code to find elements common between the two lists. \n",
    "The output list should exclude duplicate elements. i.e. if both lists have 1 twice then the output list should have 1 only once.\n",
    "The input will contain two lines with two lists.\n",
    "The output should contain a list of common elements between the two input lists.\n",
    "Sample Input:\n",
    "[1,2,3,4,5]\n",
    "[4,5,6,7,8]\n",
    "Sample Output:\n",
    "[4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "inp = ast.literal_eval(input_str)\n",
    "list1=inp[0]#first list\n",
    "list2=inp[1]#second list\n",
    "print(list(set(list1).intersection(set(list2))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sorting based on one column\n",
    "Given a dataframe, you have to sort the rows based on values of one column.\n",
    "Note: Sorting should be in descending order of values of given column\n",
    "The input will contain a column name. The output should contain the first five rows of the dataframe.\n",
    "The output will contain the first n rows of the sorted dataframe.\n",
    "Sample Input:\n",
    "TOEFL Score\n",
    "Sample Output:\n",
    "\n",
    "     Serial No.  GRE Score  TOEFL Score  University Rating  SOP  LOR   CGPA  \\\n",
    "25           26        340          120                  5  4.5   4.5  9.60   \n",
    "97           98        331          120                  3  4.0   4.0  8.96   \n",
    "81           82        340          120                  4  5.0   5.0  9.50   \n",
    "202         203        340          120                  5  4.5   4.5  9.91   \n",
    "203         204        334          120                  5  4.0   5.0  9.87   \n",
    "\n",
    "     Research  Chance of Admit   \n",
    "25          1              0.94  \n",
    "97          1              0.86  \n",
    "81          1              0.96  \n",
    "202         1              0.97  \n",
    "203         1              0.97  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "col=input()\n",
    "df=pd.read_csv(\"https://media-doselect.s3.amazonaws.com/generic/RM8r5NBrJdA4QeVZXvwbjokwv/Admission_Predict.csv\")\n",
    "print(df.sort_values(by=[col],ascending=False).head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Survival of?\n",
    "Given is a dataframe with data of passengers of the ship Titanic. The dataframe looks as follows:\n",
    "\n",
    "   PassengerId  Survived  Pclass  \\\n",
    "0            1         0       3   \n",
    "1            2         1       1   \n",
    "2            3         1       3   \n",
    "3            4         1       1   \n",
    "4            5         0       3   \n",
    "\n",
    "                                                Name     Sex   Age  SibSp  \\\n",
    "0                            Braund, Mr. Owen Harris    male  22.0      1   \n",
    "1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0      1   \n",
    "2                             Heikkinen, Miss. Laina  female  26.0      0   \n",
    "3       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  35.0      1   \n",
    "4                           Allen, Mr. William Henry    male  35.0      0   \n",
    "\n",
    "   Parch            Ticket     Fare Cabin Embarked  \n",
    "0      0         A/5 21171   7.2500   NaN        S  \n",
    "1      0          PC 17599  71.2833   C85        C  \n",
    "2      0  STON/O2. 3101282   7.9250   NaN        S  \n",
    "3      0            113803  53.1000  C123        S  \n",
    "4      0            373450   8.0500   NaN        S  \n",
    "Here, the \"Survived\" column has \"1\" if the passenger has survived. Otherwise, it contains \"0\". The Pclass column indicates the class the passenger was travelling in(1st class, 2nd class and so on).\n",
    "\n",
    "Write a Pandas program to create a Pivot table and find survival rate by the given column on various classes according to Pclass.\n",
    "Sample Input:\n",
    "Sex\n",
    "Sample Output:\n",
    "Pclass         1         2         3\n",
    "Sex                                 \n",
    "female  0.968085  0.921053  0.500000\n",
    "male    0.368852  0.157407  0.135447"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "df=pd.read_csv(\"https://media-doselect.s3.amazonaws.com/generic/pLMXoA0GZNAPMRNrdnn88pOxb/train.csv\")\n",
    "col=input()\n",
    "print(df.pivot_table('Survived', index=[col], columns='Pclass'))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Valid email ID\n",
    "Description\n",
    "Consider that email IDs are supposed to be for the following format:\n",
    "username@website.extension.\n",
    "Here, there are three conditions to keep in mind:\n",
    "1. The username can only contain characters 0-9, a-z and A-Z.\n",
    "2. The website name can contain only characters a-z\n",
    "3. The extension can have 2 or 3 alphabets(a-z).\n",
    "\n",
    "Given an email ID, you have to determine if it is valid or not.\n",
    "\n",
    "Sample Input:\n",
    "prerna@upgrad.com\n",
    "\n",
    "Sample Output:\n",
    "valid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def checkmail(email):\n",
    "    username=email.split(\"@\")[0]\n",
    "    #checking if the email id has more than one @ symbols\n",
    "    if len(email.split(\"@\"))>2:\n",
    "        return(\"invalid\")\n",
    "    else:\n",
    "    #checking for strictly alphanumeric emailId\n",
    "        if not username.isalnum():\n",
    "            return(\"invalid\")\n",
    "    #checking website name\n",
    "    website=email.split(\"@\")[1].split(\".\")[0]\n",
    "    if not website.isalpha():\n",
    "        return(\"invalid\")\n",
    "    #checking extension\n",
    "    extension=email.split(\"@\")[1].split(\".\")[1]\n",
    "    if (len(extension)>3) | (len(extension)<2) | (extension.isalpha()!=True):\n",
    "        return(\"invalid\")\n",
    "    return(\"valid\")\n",
    "email=input()\n",
    "print(checkmail(email))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Flatten a list\n",
    "Description\n",
    "Given a nested list, write python code to flatten the list.\n",
    "Note: The input list will strictly have 2 levels, i.e. the list will be of the form [[1,2],[3,4]]. Inputs like [1,[2,3]] and [[1,[2,3],4],5] are not applicable.\n",
    "\n",
    "For example: If the input list is :\n",
    "[[1,2,3],[4,5],[6,7,8,9]]\n",
    "Then the output should be:\n",
    "[1,2,3,4,5,6,7,8,9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "flat_list = []\n",
    "for sublist in input_list:\n",
    "    for item in sublist:\n",
    "        flat_list.append(item)\n",
    "print(flat_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Squares\n",
    "Description\n",
    "Given a list of positive integers, you have to find numbers divisible by 3 and replace them with their squares. \n",
    "For example, consider the list below:\n",
    "Input: [1,2,3,4,5,6]\n",
    "The output for the above list would be: [1,2,9,4,5,36]. Because 3 and 6 were divisible by 3, these numbers were replaced with their squares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "a=[]\n",
    "for n in input_list:\n",
    "    if(n%3==0):\n",
    "        a.append((n*n))\n",
    "    else:\n",
    "        a.append(n)\n",
    "        \n",
    "print(a)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast,sys\n",
    "input_str = sys.stdin.read()\n",
    "input_list = ast.literal_eval(input_str)\n",
    "output = [x if x%3!=0 else x**2 for x in input_list]\n",
    "print(output)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A weird sum\n",
    "Description\n",
    "Write a program that computes the value of n+nn+nnn+nnnn with a given digit as the value of n.\n",
    "For example, if n=9 , then you have to find the value of 9+99+999+9999."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=input()\n",
    "\n",
    "#start writing your code here\n",
    "total=0\n",
    "s=int(n)\n",
    "for i in range(1,5):\n",
    "    sum=(n*i)\n",
    "    total=int(sum)+int(total)\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=input()\n",
    "n1 = int( \"%s\" % n)\n",
    "n2 = int( \"%s%s\" % (n,n) )\n",
    "n3 = int( \"%s%s%s\" % (n,n,n) )\n",
    "n4 = int( \"%s%s%s%s\" % (n,n,n,n) )\n",
    "\n",
    "print (n1+n2+n3+n4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Frequent Letters\n",
    "Description\n",
    "Given a string, you have to find the first n most frequent characters in it.\n",
    "You have to print the three letters in alphabetically sorted order.\n",
    "The input will contain two lines, the first line will contain a string and the second line will contain the letter n.\n",
    "The output should be a list of n most frequent letters in alphabetically sorted order.\n",
    "Note: If there are two letters with the same frequency, then the alphabetically preceding alphabet should be picked first. (For example, in \"aabbccc\", if n=2, then output list would have c and a.)\n",
    "Sample Input:\n",
    "ddddaacccb\n",
    "3\n",
    "Sample Output:\n",
    "['a', 'c', 'd']\n",
    "\n",
    "In the above example, the order of frequencies is : d>c>a>b\n",
    "Here, d,c and a are three most frequent characters which are displayed in alphabetically sorted order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter \n",
    "string=input()\n",
    "n=int(input())\n",
    "#write your code here\n",
    "c=Counter(string)\n",
    "#c.most_common(3)\n",
    "a=dict(c.most_common(n))\n",
    "#collections.OrderedDict(a)\n",
    "print(sorted(a.keys()))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string=input()\n",
    "n=int(input())\n",
    "import collections\n",
    "out=[collections.Counter(string).most_common(i+1)[i][0] for i in range(n)]\n",
    "out.sort()\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2D array\n",
    "Description\n",
    "Write Python code which takes 2 numbers x and y as input and generates a 2-dimensional numpy array where value in the i-th row and j-th column of the array should be (i+j)/2.\n",
    "Note: i=0,1,...x-1 and j=0,1....,y-1\n",
    "The input will have two lines with x and y respectively.\n",
    "The output should be a 2D numpy array.\n",
    "Sample Input:\n",
    "3\n",
    "4\n",
    "Sample Output:\n",
    "\n",
    "[[0.  0.5 1.  1.5]\n",
    " [0.5 1.  1.5 2. ]\n",
    " [1.  1.5 2.  2.5]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "x=int(input())\n",
    "y=int(input())\n",
    "#write your code here\n",
    "\n",
    "def d_arr(row,col):\n",
    "    arr = [[(i+j)/2 for j in range(y)] for i in range(x)]\n",
    "    final_arr = np.matrix(arr)\n",
    "    return final_arr\n",
    "\n",
    "print(d_arr(x,y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=int(input())\n",
    "y=int(input())\n",
    "from numpy import zeros\n",
    "a = zeros([x,y])\n",
    "for row in range(x):\n",
    "    for col in range(y):\n",
    "        a[row][col]= (row+col)/2\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}