Data Structures in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is data structure in programming language?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A data structure is a particular way of organizing data in a computer so that it can be used effectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Structures in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has four basic inbuilt data structures namely Lists, Dictionary, Tuple and Set. These almost cover 80% of the our real world data structures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list is similar to an array that consists of a group of elements or items. Just like an array, a list can store elements. But, there is one major difference between an array and a list. An array can store only one type of elements whereas a list can store different types of elements. Hence lists are more versatile and useful than an array. Perhaps lists are the most used datatype in Python programs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:32.995444Z",
     "start_time": "2020-02-02T03:12:32.935626Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'a', 'string', 3]\n"
     ]
    }
   ],
   "source": [
    "# A simple list \n",
    "# Declaring a list \n",
    "L = [1, \"a\" , \"string\" , 1+2] \n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:33.031397Z",
     "start_time": "2020-02-02T03:12:32.999439Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T15:13:35.571908Z",
     "start_time": "2020-02-01T15:13:35.567919Z"
    }
   },
   "source": [
    "Creating Lists using range() function\n",
    "\n",
    "\n",
    "range(start, stop, stepsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:33.046168Z",
     "start_time": "2020-02-02T03:12:33.035392Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "list_range = list(range(0,10,1))\n",
    "print(list_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "A tuple is a python sequence which stores a group of elements or items. Tuples are similar to lists but the main difference is tuples are immutable whereas lists are mutable. Since tuples are immutable, once we create a tuple we cannot modify its elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:33.058110Z",
     "start_time": "2020-02-02T03:12:33.050119Z"
    }
   },
   "outputs": [],
   "source": [
    "tup1 = ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:33.162248Z",
     "start_time": "2020-02-02T03:12:33.062105Z"
    }
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "tuple index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-b620b181ea7e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtup1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: tuple index out of range"
     ]
    }
   ],
   "source": [
    "tup1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:55.950915Z",
     "start_time": "2020-02-02T03:12:55.942438Z"
    }
   },
   "outputs": [],
   "source": [
    "tup2 = (10, 20, 'Hyderabad')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:56.361982Z",
     "start_time": "2020-02-02T03:12:56.349178Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hyderabad'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup2[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "A dictionary represents a group of elements arranged in the form of key-value pairs. In the dictionary, the first element is considered as 'key' and the immediate next element is taken as its 'value'. The key and its value is separated by a colon (:).\n",
    "\n",
    "All the key-value pairs in a dictionary are inserted in curly braces {}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:56.910347Z",
     "start_time": "2020-02-02T03:12:56.902473Z"
    }
   },
   "outputs": [],
   "source": [
    "dict_1 = {'Name': 'Chandra',\n",
    "        'ID': 54321,\n",
    "        'Salary': 12500}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:57.070479Z",
     "start_time": "2020-02-02T03:12:57.060916Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Chandra', 'ID': 54321, 'Salary': 12500}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Set is an unordered collection data type that is iterable, mutable and has no duplicate elements. Python’s set class represents the mathematical notion of a set. The major advantage of using a set, as opposed to a list, is that it has a highly optimized method for checking whether a specific element is contained in the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:57.771913Z",
     "start_time": "2020-02-02T03:12:57.763956Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set: \n",
      "{'c', 'b', 'a'}\n"
     ]
    }
   ],
   "source": [
    "# Python program to \n",
    "# demonstrate sets \n",
    "  \n",
    "# Same as {\"a\", \"b\", \"c\"} \n",
    "Set = set([\"a\", \"b\", \"c\"]) \n",
    "  \n",
    "print(\"Set: \") \n",
    "print(Set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Union Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:58.236986Z",
     "start_time": "2020-02-02T03:12:58.227902Z"
    }
   },
   "outputs": [],
   "source": [
    "A = {1, 2, 3, 4, 5}\n",
    "B = {4, 5, 6, 7, 8}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Union of A and B is a set of all elements from both sets.\n",
    "\n",
    "Union is performed using | operator. Same can be accomplished using the method union()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:58.648158Z",
     "start_time": "2020-02-02T03:12:58.639282Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7, 8}\n"
     ]
    }
   ],
   "source": [
    "print(A|B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:59.026303Z",
     "start_time": "2020-02-02T03:12:59.018313Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.union(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:12:59.171281Z",
     "start_time": "2020-02-02T03:12:59.163713Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.union(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Intersection Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Intersection of A and B is a set of elements that are common in both sets.\n",
    "\n",
    "Intersection is performed using & operator. Same can be accomplished using the method intersection()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:00.175289Z",
     "start_time": "2020-02-02T03:13:00.169744Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{4, 5}\n"
     ]
    }
   ],
   "source": [
    "print(A&B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:00.351329Z",
     "start_time": "2020-02-02T03:13:00.341774Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.intersection(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:00.552432Z",
     "start_time": "2020-02-02T03:13:00.543836Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.intersection(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Difference Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Difference of A and B (A - B) is a set of elements that are only in A but not in B. Similarly, B - A is a set of element in B but not in A."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:01.117529Z",
     "start_time": "2020-02-02T03:13:01.109473Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "print(A - B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:01.277476Z",
     "start_time": "2020-02-02T03:13:01.269874Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{8, 6, 7}\n"
     ]
    }
   ],
   "source": [
    "print(B - A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:01.467495Z",
     "start_time": "2020-02-02T03:13:01.455195Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.difference(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:01.647532Z",
     "start_time": "2020-02-02T03:13:01.635549Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{6, 7, 8}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.difference(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Symmetric Difference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Symmetric Difference of A and B is a set of elements in both A and B except those that are common in both."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Symmetric difference is performed using ^ operator. Same can be accomplished using the method symmetric_difference()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:02.403812Z",
     "start_time": "2020-02-02T03:13:02.395782Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 6, 7, 8}\n"
     ]
    }
   ],
   "source": [
    "print(A ^ B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:02.600405Z",
     "start_time": "2020-02-02T03:13:02.590001Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 6, 7, 8}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.symmetric_difference(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:02.976234Z",
     "start_time": "2020-02-02T03:13:02.968284Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 6, 7, 8}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.symmetric_difference(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists - Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:03.370046Z",
     "start_time": "2020-02-02T03:13:03.361892Z"
    }
   },
   "outputs": [],
   "source": [
    "# Lets declare two list \n",
    "\n",
    "list_1 = [1,1,2,2,3,3,4,4]\n",
    "list_2 = [5,5,6,6,7,7,8,8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Displaying list element by position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:03.733753Z",
     "start_time": "2020-02-02T03:13:03.721477Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:03.891123Z",
     "start_time": "2020-02-02T03:13:03.883967Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_1[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T02:59:28.173367Z",
     "start_time": "2020-02-02T02:59:28.161062Z"
    }
   },
   "source": [
    "## Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:04.200470Z",
     "start_time": "2020-02-02T03:13:04.188020Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Returns first occurance of x in list\n",
    "# list_name.index(x)\n",
    "list_1.index(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T02:59:28.352023Z",
     "start_time": "2020-02-02T02:59:28.339864Z"
    }
   },
   "source": [
    "## Append"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:04.654795Z",
     "start_time": "2020-02-02T03:13:04.646771Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 2, 3, 3, 4, 4, 9]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# append x in the end of the list\n",
    "# list_name(x)\n",
    "list_1.append(9)\n",
    "list_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:08:01.312481Z",
     "start_time": "2020-02-02T03:08:01.304963Z"
    }
   },
   "source": [
    "## Insert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:05.081741Z",
     "start_time": "2020-02-02T03:13:05.069960Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 10, 2, 3, 3, 4, 4, 9]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inserts x in the position specified by i\n",
    "# list_name(i,x)\n",
    "list_1.insert(3,10)\n",
    "list_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T02:59:28.834361Z",
     "start_time": "2020-02-02T02:59:28.822095Z"
    }
   },
   "source": [
    "## Extend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:05.550798Z",
     "start_time": "2020-02-02T03:13:05.538849Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 10, 2, 3, 3, 4, 4, 9, 5, 5, 6, 6, 7, 7, 8, 8]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# appends other list1 to existing list\n",
    "# list.extend(list1)\n",
    "list_1.extend(list_2)\n",
    "list_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T02:59:29.193246Z",
     "start_time": "2020-02-02T02:59:29.185121Z"
    }
   },
   "source": [
    "## Pop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:05.986516Z",
     "start_time": "2020-02-02T03:13:05.974910Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 5, 6, 6, 7, 7, 8]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Removes the ending element from the list\n",
    "list_2.pop()\n",
    "list_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T02:59:47.065449Z",
     "start_time": "2020-02-02T02:59:47.053469Z"
    }
   },
   "source": [
    "## Reverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:06.380156Z",
     "start_time": "2020-02-02T03:13:06.367783Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 7, 7, 6, 6, 5, 5]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reverse the sequence of elements in the list\n",
    "list_2.reverse()\n",
    "list_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T02:59:51.837855Z",
     "start_time": "2020-02-02T02:59:51.829869Z"
    }
   },
   "source": [
    "## Count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:06.763551Z",
     "start_time": "2020-02-02T03:13:06.755564Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Count the occurance of an element in a list\n",
    "list_2.count(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:07.150178Z",
     "start_time": "2020-02-02T03:13:07.138485Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 7, 7, 6, 6, 5, 5]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_2.sort(reverse=True)\n",
    "list_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making List through Range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating list through Range:\n",
    "range(start, stop, stepsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:07.909262Z",
     "start_time": "2020-02-02T03:13:07.901557Z"
    }
   },
   "outputs": [],
   "source": [
    "list_3 = list(range(2,20,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:08.123747Z",
     "start_time": "2020-02-02T03:13:08.112136Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10, 12, 14, 16, 18]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:08.515427Z",
     "start_time": "2020-02-02T03:13:08.503358Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10, 12, 14, 16, 18]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:08.712056Z",
     "start_time": "2020-02-02T03:13:08.704036Z"
    }
   },
   "outputs": [],
   "source": [
    "list_4 = list_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:08.895155Z",
     "start_time": "2020-02-02T03:13:08.886544Z"
    }
   },
   "outputs": [],
   "source": [
    "list_4.append(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:09.076211Z",
     "start_time": "2020-02-02T03:13:09.063681Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:09.208027Z",
     "start_time": "2020-02-02T03:13:09.196003Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:09.651830Z",
     "start_time": "2020-02-02T03:13:09.635968Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 7, 7, 6, 6, 5, 5]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:09.805813Z",
     "start_time": "2020-02-02T03:13:09.798847Z"
    }
   },
   "outputs": [],
   "source": [
    "list_5 = list_2.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:09.966343Z",
     "start_time": "2020-02-02T03:13:09.959455Z"
    }
   },
   "outputs": [],
   "source": [
    "list_5.append(45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:10.097735Z",
     "start_time": "2020-02-02T03:13:10.085718Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 7, 7, 6, 6, 5, 5, 45]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:13:10.353810Z",
     "start_time": "2020-02-02T03:13:10.345658Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 7, 7, 6, 6, 5, 5]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question: 1\n",
    "Create a program to take 'n': number of elements in a list. Then these 'n' inputs from the user and store them in a list and print them on screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:23:48.210508Z",
     "start_time": "2020-02-02T03:23:34.206049Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of elements you want in the list:\n",
      "3\n",
      "Enter number  1 :\n",
      "4\n",
      "Enter number  2 :\n",
      "5\n",
      "Enter number  3 :\n",
      "8\n",
      "[4, 5, 8]\n"
     ]
    }
   ],
   "source": [
    "print(\"Enter the number of elements you want in the list:\")\n",
    "num_of_elements = int(input())\n",
    "list_elements = []\n",
    "\n",
    "for i in range(num_of_elements):\n",
    "    print(\"Enter number \",i+1, \":\")\n",
    "    num = int(input())\n",
    "    list_elements.append(num)\n",
    "\n",
    "print(list_elements)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question: 2\n",
    "Take 5 integer inputs from user and store them in a list. Again ask user to give a number. Now, tell user whether that number is present in list or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:30:13.808927Z",
     "start_time": "2020-02-02T03:30:05.822301Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number  1 :\n",
      "1\n",
      "Enter number  2 :\n",
      "2\n",
      "Enter number  3 :\n",
      "3\n",
      "Enter number  4 :\n",
      "4\n",
      "Enter number  5 :\n",
      "5\n",
      "Check for a number\n",
      "4\n",
      "Yes\n"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "for i in range(0,5):\n",
    "    print(\"Enter number \",i+1, \":\")\n",
    "    num = int(input())\n",
    "    a.append(num)\n",
    "\n",
    "print(\"Check for a number\")\n",
    "n = int(input())\n",
    "\n",
    "if a.count(n)>0:\n",
    "    print(\"Yes\")\n",
    "else:\n",
    "    print(\"No\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question: 3\n",
    "Take 6 input from the user and check weather the number entered is even or odd. Create a list which store 'even' or 'odd' based on the number entered. Print this created list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:37:55.105771Z",
     "start_time": "2020-02-02T03:37:46.068331Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number  1 :\n",
      "2\n",
      "Enter number  2 :\n",
      "3\n",
      "Enter number  3 :\n",
      "4\n",
      "Enter number  4 :\n",
      "5\n",
      "Enter number  5 :\n",
      "6\n",
      "Enter number  6 :\n",
      "7\n",
      "['even', 'odd', 'even', 'odd', 'even', 'odd']\n"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "for i in range(0,6):\n",
    "    print(\"Enter number \",i+1, \":\")\n",
    "    num = int(input())\n",
    "    \n",
    "    if num%2==0:\n",
    "        a.append('even')\n",
    "    else:\n",
    "        a.append('odd')\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question: 4\n",
    "\n",
    "Take 10 integer inputs from user and print the following:\n",
    "- number of positive numbers\n",
    "- number of negative numbers\n",
    "- number of odd numbers\n",
    "- number of even numbers\n",
    "- number of 0s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:39:38.017149Z",
     "start_time": "2020-02-02T03:39:17.260201Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number\n",
      "2\n",
      "Enter number\n",
      "3\n",
      "Enter number\n",
      "-3\n",
      "Enter number\n",
      "4\n",
      "Enter number\n",
      "6\n",
      "Enter number\n",
      "7\n",
      "Enter number\n",
      "4\n",
      "Enter number\n",
      "90\n",
      "Enter number\n",
      "-544\n",
      "Enter number\n",
      "78\n",
      "EVEN : 7 ODD : 3 ZERO : 0 POSITIVE : 8 NEGATIVE : 2\n"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "for i in range(0,10):\n",
    "    print(\"Enter number\")\n",
    "    num = int(input())\n",
    "    a.append(num)\n",
    "\n",
    "\n",
    "odd = 0\n",
    "even = 0\n",
    "zero = 0\n",
    "positive = 0\n",
    "negative = 0\n",
    "\n",
    "\n",
    "for i in a:\n",
    "    if i == 0:\n",
    "        zero = zero+1\n",
    "    if i>0:\n",
    "        positive = positive + 1\n",
    "    else:\n",
    "        negative = negative + 1\n",
    "    if i%2 == 0:\n",
    "        even = even + 1\n",
    "    else:\n",
    "        odd = odd + 1\n",
    "    \n",
    "print(\"EVEN :\",even,\"ODD :\",odd,\"ZERO :\",zero,\"POSITIVE :\",positive,\"NEGATIVE :\",negative)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 5:\n",
    "Create  a list and remove duplicates from it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:47:51.543845Z",
     "start_time": "2020-02-02T03:47:51.537903Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[32, 1, 2, 3, 12]\n"
     ]
    }
   ],
   "source": [
    "# Method 1\n",
    "a = [1,2,3,2,1,3,12,12,32]\n",
    "i = 0\n",
    "temp = []\n",
    "for i in a:\n",
    "    if i not in temp:\n",
    "        temp.append(i)\n",
    "\n",
    "#Method 2 -> Python way\n",
    "a = [1,2,3,2,1,3,12,12,32]\n",
    "a = list(set(a))\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionary - Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:53:19.710983Z",
     "start_time": "2020-02-02T03:53:19.705987Z"
    }
   },
   "outputs": [],
   "source": [
    "dict_1 = {'name': 'Jack',\n",
    "          'age': 27,\n",
    "          'address': 'Downtown'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:53:23.932174Z",
     "start_time": "2020-02-02T03:53:23.923176Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Jack', 'age': 27, 'address': 'Downtown'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clear"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:55:29.942711Z",
     "start_time": "2020-02-02T03:55:29.938720Z"
    }
   },
   "outputs": [],
   "source": [
    "# Remove all items form the dictionary.\n",
    "dict_1.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:55:32.556387Z",
     "start_time": "2020-02-02T03:55:32.550402Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:21:09.210250Z",
     "start_time": "2020-02-02T07:21:09.196108Z"
    }
   },
   "outputs": [],
   "source": [
    "dict_2 = dict_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:21:37.543179Z",
     "start_time": "2020-02-02T07:21:37.539192Z"
    }
   },
   "outputs": [],
   "source": [
    "dict_2.update({\"C\":431})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:21:42.415571Z",
     "start_time": "2020-02-02T07:21:42.410625Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Jack', 'age': 27, 'address': 'Downtown', 'C': 431}"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:20:57.113985Z",
     "start_time": "2020-02-02T07:20:57.099740Z"
    }
   },
   "outputs": [],
   "source": [
    "dict_1 = {'name': 'Jack',\n",
    "          'age': 27,\n",
    "          'address': 'Downtown'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:56:43.912775Z",
     "start_time": "2020-02-02T03:56:43.908783Z"
    }
   },
   "outputs": [],
   "source": [
    "d_2 = dict_1.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:56:47.065373Z",
     "start_time": "2020-02-02T03:56:47.059414Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Jack', 'age': 27, 'address': 'Downtown'}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## fromkeys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:59:44.296538Z",
     "start_time": "2020-02-02T03:59:44.292548Z"
    }
   },
   "outputs": [],
   "source": [
    "# Return a new dictionary with keys from seq and value equal to v (defaults to None)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T03:59:20.931369Z",
     "start_time": "2020-02-02T03:59:20.926345Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'e': 3, 'a': 3, 'i': 3}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys = {'a','e','i'}\n",
    "value = 3\n",
    "d_2.fromkeys(keys, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:24:14.458726Z",
     "start_time": "2020-02-02T07:24:14.454740Z"
    }
   },
   "outputs": [],
   "source": [
    "list_1 = ['a','b','c']\n",
    "list_2 = [5,6,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:24:32.628588Z",
     "start_time": "2020-02-02T07:24:32.612657Z"
    }
   },
   "outputs": [],
   "source": [
    "dict_3 = dict(zip(list_1,list_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:24:39.556067Z",
     "start_time": "2020-02-02T07:24:39.551082Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 5, 'b': 6, 'c': 7}"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## get"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T04:00:06.383193Z",
     "start_time": "2020-02-02T04:00:06.380237Z"
    }
   },
   "outputs": [],
   "source": [
    "# Return the value of key. If key doesnot exit, return d (defaults to None)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T04:00:23.273158Z",
     "start_time": "2020-02-02T04:00:23.268170Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Jack', 'age': 27, 'address': 'Downtown'}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T04:01:00.294009Z",
     "start_time": "2020-02-02T04:01:00.289022Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jack'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1.get('name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T04:02:57.663581Z",
     "start_time": "2020-02-02T04:02:57.660629Z"
    }
   },
   "outputs": [],
   "source": [
    "#Return a new view of the dictionary's items (key, value)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T04:03:30.894563Z",
     "start_time": "2020-02-02T04:03:30.889575Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('name', 'Jack'), ('age', 27), ('address', 'Downtown')])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T04:04:24.057649Z",
     "start_time": "2020-02-02T04:04:24.054658Z"
    }
   },
   "outputs": [],
   "source": [
    "# We make use of items when we want to perform a 'for' loop operation using dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T04:05:35.838844Z",
     "start_time": "2020-02-02T04:05:35.829867Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['name', 'age', 'address'])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Return a new view of the dictionary's keys.\n",
    "dict_1.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T04:06:42.429396Z",
     "start_time": "2020-02-02T04:06:42.422416Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['Jack', 27, 'Downtown'])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return a new view of the dictionary's values\n",
    "dict_1.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T04:08:36.867214Z",
     "start_time": "2020-02-02T04:08:36.861229Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Jack', 'age': 27, 'address': 'Downtown', 'C': 431}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Update the dictionary with the key/value pairs from other, overwriting existing keys.\n",
    "\n",
    "dict_1.update({\"C\":431})\n",
    "dict_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T04:08:53.568350Z",
     "start_time": "2020-02-02T04:08:53.563364Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Daniel', 'age': 27, 'address': 'Downtown', 'C': 431}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1.update({\"name\":'Daniel'})\n",
    "dict_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating over a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T04:09:48.574808Z",
     "start_time": "2020-02-02T04:09:48.567827Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name Daniel\n",
      "age 27\n",
      "address Downtown\n",
      "C 431\n"
     ]
    }
   ],
   "source": [
    "# Iterating over a dictionary\n",
    "for k,v in dict_1.items():\n",
    "    print(k,v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionary Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 1:\n",
    "Create a dictionary and remove the key value pair if the value is even\n",
    "\n",
    "ex: input {\"A\": 123,\"B\": 431,\"C\":56}\n",
    "\n",
    "output {\"C\":56}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T04:10:50.993034Z",
     "start_time": "2020-02-02T04:10:50.988049Z"
    }
   },
   "outputs": [],
   "source": [
    "dict_1 = {\"A\": 123,\"B\": 431,\"C\":56}\n",
    "temp_dict = {}\n",
    "for k,v in dict_1.items():\n",
    "    if v%2==0:\n",
    "        temp_dict.update({k:v})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2:\n",
    "With a given integral number n, write a program to generate a dictionary that contains (i, i*i) such that is an integral number between 1 and n (both included). and then the program should print the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:05:44.842286Z",
     "start_time": "2020-02-02T05:05:43.586509Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: \n",
      "6\n",
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}\n"
     ]
    }
   ],
   "source": [
    "print(\"Enter a number: \")\n",
    "n=int(input())\n",
    "d=dict()\n",
    "\n",
    "for i in range(1,n+1):\n",
    "    d[i]=i*i\n",
    "    \n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 3:\n",
    "Write a program which will:\n",
    "1. Find all such numbers which are divisible by 7 but are not a multiple of 5, between 2000 and 2100 (both included).\n",
    "2. Find all such numbers which are divisible by 9 but are not a multiple of 5, between 2000 and 2100 (both included).\n",
    "\n",
    "Store these list of number in a dictionary in following way:\n",
    "\n",
    "{'7_not_5': [list of number],\n",
    " '9_not_5 : [list of number]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:00:43.090827Z",
     "start_time": "2020-02-02T05:00:43.079287Z"
    }
   },
   "outputs": [],
   "source": [
    "seven = []\n",
    "nine = []\n",
    "\n",
    "for i in range(2000, 2101):\n",
    "    if (i%7==0) and (i%5!=0):\n",
    "        seven.append(i)\n",
    "    if (i%9==0) and (i%5!=0):\n",
    "        nine.append(i)\n",
    "\n",
    "dict_1 = {'7_not_5':seven,\n",
    "         '9_not_5':nine}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:00:43.571344Z",
     "start_time": "2020-02-02T05:00:43.559174Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'7_not_5': [2002,\n",
       "  2009,\n",
       "  2016,\n",
       "  2023,\n",
       "  2037,\n",
       "  2044,\n",
       "  2051,\n",
       "  2058,\n",
       "  2072,\n",
       "  2079,\n",
       "  2086,\n",
       "  2093],\n",
       " '9_not_5': [2007, 2016, 2034, 2043, 2052, 2061, 2079, 2088, 2097]}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# User Defined Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function is a block of code which only runs when it is called.\n",
    "\n",
    "You can pass data, known as parameters, into a function.\n",
    "\n",
    "A function can return data as a result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a Function\n",
    "\n",
    "In Python a function is defined using the def keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:23:59.615066Z",
     "start_time": "2020-02-02T05:23:59.607073Z"
    }
   },
   "outputs": [],
   "source": [
    "def my_function():\n",
    "    print(\"Hello from a function\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calling a Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:24:05.566396Z",
     "start_time": "2020-02-02T05:24:05.558136Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from a function\n"
     ]
    }
   ],
   "source": [
    "my_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arguments/Parameters\n",
    "\n",
    "Information can be passed into functions as arguments.\n",
    "\n",
    "Arguments are specified after the function name, inside the parentheses. You can add as many arguments as you want, just separate them with a comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:32:42.312572Z",
     "start_time": "2020-02-02T05:32:42.304796Z"
    }
   },
   "outputs": [],
   "source": [
    "def my_function(fname):\n",
    "    print(\"Greetings from \" + fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:32:42.540962Z",
     "start_time": "2020-02-02T05:32:42.532591Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Greetings from Devesh\n"
     ]
    }
   ],
   "source": [
    "my_function('Devesh')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:32:57.206363Z",
     "start_time": "2020-02-02T05:32:57.198366Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Greetings from Sidharth\n"
     ]
    }
   ],
   "source": [
    "my_function(\"Sidharth\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Number of Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, a function must be called with the correct number of arguments. Meaning that if your function expects 2 arguments, you have to call the function with 2 arguments, not more, and not less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:42:53.448492Z",
     "start_time": "2020-02-02T05:42:53.440503Z"
    }
   },
   "outputs": [],
   "source": [
    "def my_function(fname, lname):\n",
    "    print(fname + \" \" + lname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:46:39.777466Z",
     "start_time": "2020-02-02T05:46:39.769787Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Name Second Name\n"
     ]
    }
   ],
   "source": [
    "my_function(\"First Name\", \"Second Name\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Default Parameter Value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following example shows how to use a default parameter value.\n",
    "\n",
    "If we call the function without argument, it uses the default value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:48:36.054443Z",
     "start_time": "2020-02-02T05:48:36.049030Z"
    }
   },
   "outputs": [],
   "source": [
    "def my_function(country = \"India\"):\n",
    "    print(\"I am from \" + country)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:48:37.316389Z",
     "start_time": "2020-02-02T05:48:37.308399Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am from India\n"
     ]
    }
   ],
   "source": [
    "my_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:48:53.874642Z",
     "start_time": "2020-02-02T05:48:53.866687Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am from United States\n"
     ]
    }
   ],
   "source": [
    "my_function(\"United States\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passing a List as an Argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can send any data types of argument to a function (string, number, list, dictionary etc.), and it will be treated as the same data type inside the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:36:23.746182Z",
     "start_time": "2020-02-02T05:36:23.737346Z"
    }
   },
   "outputs": [],
   "source": [
    "def joey_loves_food(food):\n",
    "    for x in food:\n",
    "        print(x)\n",
    "\n",
    "snacks = [\"sandwich\",\"lasagna\",\"turkey\",\"jam\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:36:30.014525Z",
     "start_time": "2020-02-02T05:36:30.005580Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sandwich\n",
      "lasagna\n",
      "turkey\n",
      "jam\n"
     ]
    }
   ],
   "source": [
    "joey_loves_food(snacks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Return Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:51:22.565221Z",
     "start_time": "2020-02-02T05:51:22.560294Z"
    }
   },
   "outputs": [],
   "source": [
    "def my_function(x):\n",
    "    return 5 * x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:51:23.112344Z",
     "start_time": "2020-02-02T05:51:23.104835Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "25\n",
      "45\n"
     ]
    }
   ],
   "source": [
    "print(my_function(3))\n",
    "print(my_function(5))\n",
    "print(my_function(9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A lambda function is a small anonymous function.\n",
    "\n",
    "A lambda function can take any number of arguments, but can only have one expression.\n",
    "\n",
    "lambda arguments : expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# A lambda function that adds 10 to the number passed in as an argument, and print the result:\n",
    "\n",
    "x = lambda a : a + 10\n",
    "\n",
    "print(x(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambda functions can take any number of arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T06:08:49.358170Z",
     "start_time": "2020-02-02T06:08:49.350185Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "# A lambda function that multiplies argument a with argument b and print the result:\n",
    "\n",
    "x = lambda a, b : a * b\n",
    "print(x(5, 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T06:09:02.782083Z",
     "start_time": "2020-02-02T06:09:02.773752Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "x = lambda a, b, c : a + b + c\n",
    "print(x(5, 6, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# User Defined Functions - Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Question 1:\n",
    "Create a user defined function to add two numbers and print the sum value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T05:54:20.326730Z",
     "start_time": "2020-02-02T05:54:20.315206Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum is 11\n"
     ]
    }
   ],
   "source": [
    "def add_numbers(x,y):\n",
    "    sum = x + y\n",
    "    return sum\n",
    "\n",
    "num1 = 5\n",
    "num2 = 6\n",
    "\n",
    "print(\"The sum is\", add_numbers(num1, num2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2:\n",
    "Create a user defined function to return squares of number from 1 to 'n'. Return the squares in a list format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T06:36:41.370267Z",
     "start_time": "2020-02-02T06:36:41.366317Z"
    }
   },
   "outputs": [],
   "source": [
    "def square_num(n):\n",
    "    \n",
    "    num_list = list(range(1,n+1))\n",
    "    \n",
    "    c = [i**2 for i in num_list]\n",
    "    \n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T06:36:41.619886Z",
     "start_time": "2020-02-02T06:36:41.613907Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_num(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 3:\n",
    "Given a list with five positive integers, create a user defined function to find the minimum and maximum values that can be calculated by summing exactly four of the five integers. Then print the respective minimum and maximum values as a single line of two space-separated long integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:00:47.617868Z",
     "start_time": "2020-02-02T07:00:47.605901Z"
    }
   },
   "outputs": [],
   "source": [
    "def miniMaxSum(arr):\n",
    "    arr_main = arr\n",
    "    arr_main.sort()\n",
    "    min_sum = sum(arr_main[0:-1])\n",
    "    max_sum = sum(arr_main[1:len(arr_main)])\n",
    "    min_max = list([min_sum,max_sum])\n",
    "    return min_max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:01:30.629855Z",
     "start_time": "2020-02-02T07:01:30.625892Z"
    }
   },
   "outputs": [],
   "source": [
    "list_1 = [3,4,9,56,2]\n",
    "list_2 = [5,7,32,87,12]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:01:39.322264Z",
     "start_time": "2020-02-02T07:01:39.318307Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[18, 72]"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miniMaxSum(list_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:01:49.103070Z",
     "start_time": "2020-02-02T07:01:49.098139Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[56, 138]"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miniMaxSum(list_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem Solving"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 1:\n",
    "Given a square matrix, calculate the absolute difference between the sums of its diagonals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T06:44:25.737857Z",
     "start_time": "2020-02-02T06:44:25.732871Z"
    }
   },
   "outputs": [],
   "source": [
    "# import random\n",
    "\n",
    "# arr_2 = [[random.randint(3,9) for i in range(4)] for j in range(4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T10:33:07.070914Z",
     "start_time": "2020-02-02T10:33:07.065965Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[5, 8, 4], [3, 4, 9], [6, 5, 7]]"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T10:33:16.531888Z",
     "start_time": "2020-02-02T10:33:16.527855Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_1[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T10:34:10.448971Z",
     "start_time": "2020-02-02T10:34:10.442988Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_1[2][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T10:33:57.071610Z",
     "start_time": "2020-02-02T10:33:57.066734Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_1[1][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T10:33:16.722962Z",
     "start_time": "2020-02-02T10:33:16.718022Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[9, 9, 9, 9], [7, 4, 3, 7], [6, 3, 4, 5], [4, 8, 7, 3]]"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T10:33:16.946825Z",
     "start_time": "2020-02-02T10:33:16.940833Z"
    }
   },
   "outputs": [],
   "source": [
    "def diagonalDifference(arr):\n",
    "    n = len(arr)\n",
    "    primary_diagonal = 0\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            if i==j:\n",
    "                primary_diagonal = primary_diagonal + arr[i][j]\n",
    "    \n",
    "    secondary_diagonal = 0\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            if i+j==n-1:\n",
    "                secondary_diagonal = secondary_diagonal + arr[i][j]\n",
    "        \n",
    "   \n",
    "    difference = abs(primary_diagonal-secondary_diagonal)\n",
    "    \n",
    "    return difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T10:33:17.716838Z",
     "start_time": "2020-02-02T10:33:17.711849Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diagonalDifference(arr_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T06:45:18.854555Z",
     "start_time": "2020-02-02T06:45:18.847575Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diagonalDifference(arr_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2:\n",
    "You are in charge of the cake for your niece's birthday and have decided the cake will have one candle for each year of her total age. When she blows out the candles, she’ll only be able to blow out the tallest ones. Your task is to find out how many candles she can successfully blow out.\n",
    "\n",
    "For example, if your niece is turning 4 years old, and the cake will have 4 candles of height 4, 4, 1, 3, she will be able to blow out 2 candles successfully, since the tallest candles are of height 4 and there are 2 such candles.\n",
    "\n",
    "Create a user defined function, which takes the input:\n",
    "- age of the person\n",
    "- enter the height of the candles\n",
    "\n",
    "Output:\n",
    "- number of candles that can be blown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:16:41.262786Z",
     "start_time": "2020-02-02T07:16:41.241827Z"
    }
   },
   "outputs": [],
   "source": [
    "def birthdayCakeCandles():\n",
    "    \n",
    "    print(\"Enter age of the person: \")\n",
    "    age = int(input())\n",
    "    \n",
    "    ar = []\n",
    "\n",
    "    for i in range(age):\n",
    "        print(\"Enter height of the candles \",i+1, \":\")\n",
    "        num = int(input())\n",
    "        ar.append(num)\n",
    "        \n",
    "    ar.sort(reverse=True)\n",
    "    max_num = max(ar)\n",
    "    \n",
    "    list_max = len([x for x in ar if x == max_num])\n",
    "\n",
    "    return list_max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T07:16:57.627798Z",
     "start_time": "2020-02-02T07:16:46.634499Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter age of the person: \n",
      "5\n",
      "Enter height of the candles  1 :\n",
      "5\n",
      "Enter height of the candles  2 :\n",
      "6\n",
      "Enter height of the candles  3 :\n",
      "7\n",
      "Enter height of the candles  4 :\n",
      "7\n",
      "Enter height of the candles  5 :\n",
      "7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "birthdayCakeCandles()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 3:\n",
    "Given a time in - hour AM/PM format, convert it to military (24-hour) time.\n",
    "\n",
    "Note: Midnight is 12:00:00AM on a 12-hour clock, and 00:00:00 on a 24-hour clock. Noon is 12:00:00PM on a 12-hour clock, and 12:00:00 on a 24-hour clock.\n",
    "\n",
    "Create a user defined function, which takes\n",
    "\n",
    "input:\n",
    "- 07:05:45PM\n",
    "\n",
    "output:\n",
    "- 19:05:45\n",
    "\n",
    "Test it with inputs:\n",
    "- 12:40:22AM #(00:40:22)\n",
    "- 06:40:03AM #(06:40:03)\n",
    "- 02:34:50PM #(14:34:50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T08:48:41.418849Z",
     "start_time": "2020-02-02T08:48:41.406870Z"
    }
   },
   "outputs": [],
   "source": [
    "def timeConversion():    \n",
    "    s = input()\n",
    "    s_list = s.split(':')\n",
    "    hour = str(s_list[0])\n",
    "    minute = str(s_list[1])\n",
    "    second = str(s_list[2][:2])\n",
    "    am_pm = str(s_list[2][-2:])\n",
    "\n",
    "    if (am_pm == 'AM') and (hour=='12'):\n",
    "        new_hour = '00'\n",
    "        new_time = str(str(new_hour)+':'+minute+':'+second)\n",
    "    elif am_pm == 'AM':\n",
    "        new_time = str(str(hour)+':'+minute+':'+second)\n",
    "    elif am_pm == 'PM' and (hour=='12'):\n",
    "        new_time = str(str(hour)+':'+minute+':'+second)\n",
    "    else:\n",
    "        new_hour = int(hour) + 12\n",
    "        new_time = str(str(new_hour)+':'+minute+':'+second)\n",
    "    \n",
    "    return new_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T11:29:32.807555Z",
     "start_time": "2020-02-02T11:29:31.001965Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "07:05:45PM\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'19:05:45'"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timeConversion()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-02T11:29:54.119598Z",
     "start_time": "2020-02-02T11:29:51.945826Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "06:40:03AM\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'06:40:03'"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timeConversion()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 4:\n",
    "Gary is an avid hiker. He tracks his hikes meticulously, paying close attention to small details like topography. During his last hike he took exactly 'n' steps. For every step he took, he noted if it was an uphill,'U', or a downhill, 'D' step. Gary's hikes start and end at sea level and each step up or down represents a 1 unit change in altitude. We define the following terms:\n",
    "\n",
    "- A mountain is a sequence of consecutive steps above sea level, starting with a step up from sea level and ending with a step down to sea level.\n",
    "- A valley is a sequence of consecutive steps below sea level, starting with a step down from sea level and ending with a step up to sea level.\n",
    "\n",
    "Given Gary's sequence of up and down steps during his last hike, find and print the number of valleys he walked through.\n",
    "\n",
    "For example, if Gary's path is:\n",
    "\n",
    "s = [DDUUUUDD]\n",
    "\n",
    "He first enters a valley  units deep. Then he climbs out an up onto a mountain  units high. Finally, he returns to sea level and ends his hike.\n",
    "\n",
    "Create a User Defined Function to solve this problem with the following description:\n",
    "\n",
    "Complete the countingValleys function in the editor below. It must return an integer that denotes the number of valleys Gary traversed.\n",
    "\n",
    "countingValleys has the following parameter(s):\n",
    "\n",
    "- s: a string describing his path\n",
    "\n",
    "Test your function with following inputs:\n",
    "\n",
    "- UDDDUDUU\n",
    "- output: 1\n",
    "\n",
    "\n",
    "- DDUUDDUDUUUD\n",
    "- output: 2\n",
    "\n",
    "\n",
    "- UDUUUDUDDD\n",
    "- output: 0\n",
    "\n",
    "\n",
    "\n",
    "- DUDDDUUDUU\n",
    "- output: 2\n",
    "\n",
    "\n",
    "- DDUDDUUDUU\n",
    "- output: 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-08T17:07:00.381916Z",
     "start_time": "2020-02-08T17:07:00.373967Z"
    }
   },
   "outputs": [],
   "source": [
    "def countingValleys():\n",
    "    \n",
    "    print(\"Enter steps takens in described way: \")\n",
    "    every_step = list(input())\n",
    "\n",
    "    all_step = 0\n",
    "    c = 0\n",
    "\n",
    "    for i in every_step:\n",
    "        all_step_prev = all_step\n",
    "        if i=='U':\n",
    "            all_step = all_step + 1\n",
    "        else:\n",
    "            all_step = all_step - 1\n",
    "        \n",
    "        if (all_step_prev==-1) and (all_step==0):\n",
    "            c = c+1\n",
    "    \n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-08T17:07:28.527376Z",
     "start_time": "2020-02-08T17:07:26.486777Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter steps takens in described way: \n",
      "DDUDDUUDUU\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "countingValleys()"
   ]
  }
 ],
 "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.6.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "476.727px",
    "left": "23px",
    "top": "110.364px",
    "width": "272px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}