18-June -19 Session.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# print the highest remainder number which is lesser than n\n",
    "\n",
    "### %<N and n%x==highest\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "def remainder(n):\n",
    "    hr=0\n",
    "    v=1\n",
    "    for i in range(1,n+1):\n",
    "        r=n%i\n",
    "        if r>hr:\n",
    "            hr=r\n",
    "            v=i\n",
    "    print(v)\n",
    "    return \n",
    "remainder(5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# string convertion to list in a range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "n=int(input())\n",
    "s=input().split()\n",
    "#print(s)\n",
    "s1=[]\n",
    "for i in range(1,n):\n",
    "    for j in s:\n",
    "        s1.append(int(i))\n",
    "print(s1)\n",
    "def "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Play with numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 3\n",
      "1 2 3 4 5\n",
      "1 3\n",
      "2\n",
      "2 4\n",
      "3\n",
      "2 5\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "n=input().split()\n",
    "n[0],n[1]=int(n[0]),int(n[1])\n",
    "a=input().split()\n",
    "sum=[]\n",
    "#cumulative sum\n",
    "for i in range (0,n[0]):\n",
    "    if i==0:\n",
    "        sum.append(int(a[i]))\n",
    "    else:\n",
    "        sum.append(int(sum[i-1])+int(a[i]))\n",
    "for k in range(0,n[1]):\n",
    "    inq=input().split()\n",
    "    i=int(inq[0])\n",
    "    j=int(inq[1])\n",
    "    if i>1:\n",
    "        print((sum[j-1]-sum[i-2]) //(j-i+1))\n",
    "    else:\n",
    "        print(sum[j-1]//(j-i+1))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# special number-it has distinct prime numbers& prime factors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "factors6\n",
      "test case3\n",
      "n6\n",
      "NO\n",
      "n9\n",
      "NO\n",
      "n3\n",
      "NO\n"
     ]
    }
   ],
   "source": [
    "# function to check prime\n",
    "#function to determain number of prime factors for a given number\n",
    "def isprime(n):\n",
    "    flag=1 #intially number is prime thats y true if we found factors not prime(number dosent have factors)\n",
    "    if n==2:\n",
    "        return True\n",
    "    for i in range(2,n//2+1):\n",
    "        n%i==0\n",
    "        flag=0\n",
    "        return False\n",
    "    if flag==1:\n",
    "        return True\n",
    "#isprime(n)\n",
    "#no ofprime factors\n",
    "def numberPrimeFactors(n):\n",
    "    if isprime(n):\n",
    "        return 1\n",
    "    count =0\n",
    "    for i in range(2,n//2+1):\n",
    "        if isprime(i) and n%i==0:\n",
    "            count+=1\n",
    "    return count\n",
    "\n",
    "#numberPrimeFactors(n)     \n",
    "\n",
    "def isSpecialnumber(n,p):\n",
    "    if numberPrimeFactors(n)>=p:\n",
    "        return True\n",
    "    return False\n",
    "#isSpecialnumber(n,p)\n",
    "def solution2():\n",
    "    p=int(input(\"factors\"))\n",
    "    t=int(input(\"test case\"))\n",
    "    for i in range(0,t):\n",
    "        n=int(input(\"n\"))\n",
    "        if isSpecialnumber(n,p):\n",
    "            print(\"YES\")\n",
    "        else:\n",
    "            print(\"NO\")\n",
    "solution2()\n",
    "\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  TUPLES\n",
    "### -->denotesd as (),-->diff b/w list(mutable) and tuple(immutable)\n",
    "### -->Tuple is used to access data ,where as List -->add remove and any other changes are acceptable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "4\n",
      "(1, 3, 'sad')\n",
      "(4, 'sad', 7.901)\n"
     ]
    }
   ],
   "source": [
    "T=(1,2,3,4,\"sad\",7.901)\n",
    "T\n",
    "print(type(T))\n",
    "print(T[3])#accessing the 4 th element\n",
    "print(T[::2])#slicing with 2 step iterator\n",
    "print(T[len(T)//2:])#accessing mid elements to last"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries  {}\n",
    "### --> working on like a set(no repetations only unique data)\n",
    "### --> key=unique identifier for a value\n",
    "### -->value=data that can accssed with the key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value\n",
      "dict_keys(['k1', 'k2'])\n",
      "dict_values(['value', 'value2'])\n",
      "dict_items([('k1', 'value'), ('k2', 'value2')])\n",
      "{'k1': 'value', 'k2': 'value2', 'new': 'v3'}\n",
      "{'k1': 'value', 'k2': 'value2', 'new': 431}\n",
      "value2\n",
      "{'k1': 'value', 'new': 431}\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "d1={\"k1\":\"value\",\"k2\":\"value2\"}\n",
    "print(d1[\"k1\"])\n",
    "print(d1.keys()) #retuens as list of keys\n",
    "print(d1.values())#displayed as list of values\n",
    "print(d1.items())#returns list of tuples(keys+values)\n",
    "d1[\"new\"]=\"v3\"#adding element to dict\n",
    "print(d1)\n",
    "d1[\"new\"]=431 #update key value not a key\n",
    "print(d1)\n",
    "print(d1.pop(\"k2\"))# deleting a key and key value\n",
    "print(d1)\n",
    "print(\"k1\" in d1) #search for a key ,if theier return True,else False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bulid a contacts Application by using Dictionaries\n",
    "### *Add Contacts Remove \n",
    "### *Search Contacts\n",
    "### *Modifying Contacts\n",
    "### *List all Contacts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to add a contacts either exist or not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "contact added madhu\n"
     ]
    }
   ],
   "source": [
    "contacts={}\n",
    "def addcontact(name,number):\n",
    "    #verify that the contact doesnot already exist\n",
    "    if name not in contacts:\n",
    "        contacts[name]=number\n",
    "        print(\"contact %s added\",name)\n",
    "    else:\n",
    "        print(\"contact %s already exist\" % name)\n",
    "    return\n",
    "addcontact(\"madhu\",\"9848916931\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to search a contacts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "siddu does not exist\n"
     ]
    }
   ],
   "source": [
    "def searchcontact(name):\n",
    "    if name in contacts:\n",
    "        print(name, \":\",contacts[name])\n",
    "    else:\n",
    "        print(\"%s does not exist\" % name)\n",
    "    return\n",
    "searchcontact(\"siddu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'madhu': '9848916931', 'name1': 'phn1', 'name2': 'phn2'}"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contacts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to list out number of contacts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "madhu : 9848916931\n",
      "name1 : phn1\n",
      "name2 : phn2\n"
     ]
    }
   ],
   "source": [
    "def listvalues(contacts):\n",
    "    for key,val in contacts.items():\n",
    "        print(key,':',val)\n",
    "    '''contacts[\"name1\"]=\"phn1\"\n",
    "    contacts[\"name2\"]=\"phn2\"\n",
    "    contacts.items()'''\n",
    "listvalues(contacts)        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  importing the contacts add contacts with new contacts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 contacts added sucessfully\n",
      "{'name2': 143, 'kk': '123456u', 'kk2': '98567890-', 'nag': 98567, 'latha': 3467}\n"
     ]
    }
   ],
   "source": [
    "def importcontact(newcontacts):\n",
    "    contacts.update(newcontacts)\n",
    "    print(len(newcontacts.keys()),\"contacts added sucessfully\")\n",
    "    print(contacts)\n",
    "    return \n",
    "newcontacts={\"nag\":98567,\"latha\":3467}\n",
    "importcontact(newcontacts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to remove the key\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name2': 'phn2'}\n"
     ]
    }
   ],
   "source": [
    "def remove1(key):\n",
    "    contacts.pop(key)\n",
    "remove1(\"nag\")\n",
    "print(contacts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'modify' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-0a0610c29eb1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[1;32mreturn\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mmodify\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"k2\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'modify' is not defined"
     ]
    }
   ],
   "source": [
    "def modify1(key1):\n",
    "    d[key1]=\"143\"\n",
    "    print(d)\n",
    "    return\n",
    "modify(\"k2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'd' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-e983f374794d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0md\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'd' is not defined"
     ]
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name2': 'phn2'}"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contacts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to modify contacts and adding the elements in a dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name2': 143, 'kk': '123456u', 'kk2': '98567890-'}\n"
     ]
    }
   ],
   "source": [
    "def mode(x,y,z):\n",
    "    contacts[x]=143\n",
    "    contacts[y]=\"123456u\"\n",
    "    contacts[z]=\"98567890-\"\n",
    "    print(contacts)\n",
    "mode(\"name2\",\"kk\",\"kk2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name2': 143, 'kk': '123456u', 'kk2': '98567890-'}"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contacts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# packages and Modules\n",
    "### Package--> collection of modules(python file.py) and subpackages\n",
    "### Module-->single python file containing Functions\n",
    "### package-->subpackage-->modules-->Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2123"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#import math\n",
    "from math import floor as fl# another way of importing and re nameing the function\n",
    "fl(2123.789) #return floor values in a data with assigned name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__doc__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'acos',\n",
       " 'acosh',\n",
       " 'asin',\n",
       " 'asinh',\n",
       " 'atan',\n",
       " 'atan2',\n",
       " 'atanh',\n",
       " 'ceil',\n",
       " 'copysign',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'degrees',\n",
       " 'e',\n",
       " 'erf',\n",
       " 'erfc',\n",
       " 'exp',\n",
       " 'expm1',\n",
       " 'fabs',\n",
       " 'factorial',\n",
       " 'floor',\n",
       " 'fmod',\n",
       " 'frexp',\n",
       " 'fsum',\n",
       " 'gamma',\n",
       " 'gcd',\n",
       " 'hypot',\n",
       " 'inf',\n",
       " 'isclose',\n",
       " 'isfinite',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'ldexp',\n",
       " 'lgamma',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'modf',\n",
       " 'nan',\n",
       " 'pi',\n",
       " 'pow',\n",
       " 'radians',\n",
       " 'remainder',\n",
       " 'sin',\n",
       " 'sinh',\n",
       " 'sqrt',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tau',\n",
       " 'trunc']"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#math.pi\n",
    "from math import pi# another way of calling,importing\n",
    "pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to generate n random numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45 66 34 33 29 56 21 49 69 50 "
     ]
    }
   ],
   "source": [
    "import random\n",
    "#random.randint(0,100) #return random values from 0 to 100 with direct module calling\n",
    "def generateNrand(n,lb,ub):#by using function\n",
    "    for i in range(0,n):\n",
    "        print(random.randint(lb,ub),end=\" \")\n",
    "    \n",
    "generateNrand(10,0,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method randint in module random:\n",
      "\n",
      "randint(a, b) method of random.Random instance\n",
      "    Return random integer in range [a, b], including both end points.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(random.randint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from Packages import numerical\n",
    "from Packages.numerical import isprime #another way of function importation\n",
    "print(isprime(6))#one way of calling while include line 2\n",
    "print(numerical.isprime(2))#way of fun calling when line1 includes\n",
    "print(numerical.numberPrimeFactors(30))\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d={\"k1\":\"v1\",\"k2\":\"v2\",\"k3\":\"v3\"}\n",
    "d\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "431\n",
      "{'k1': 'v1', 'k2': 'v2', 'k3': 431}\n"
     ]
    }
   ],
   "source": [
    "def mod(key):\n",
    "    if key in d:\n",
    "        d[key]=int(input())\n",
    "    else:\n",
    "        print(\"key is not found\")\n",
    "    print(d)\n",
    "mod(\"k3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key removed\n",
      "{'k1': 'v1', 'k3': 431}\n"
     ]
    }
   ],
   "source": [
    "def rm(key):\n",
    "    if key in d:\n",
    "        d.pop(key)\n",
    "        print(\"key removed\")\n",
    "    else:\n",
    "        print(\"key  not removed\")\n",
    "    print(d)\n",
    "rm(\"k2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 5 6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[4, 5, 6]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=list(map(int,input().split()))\n",
    "type(a)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "1 3\n",
      "1 3\n",
      "2 4\n",
      "2 4\n",
      "5 8\n",
      "5 8\n",
      "3 9\n",
      "3 9\n"
     ]
    }
   ],
   "source": [
    "k=int(input())\n",
    "for i in range(k):\n",
    "    x,y=map(int,input().split())\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seating Arrangement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t=int(input())\n",
    "for i in range(t):\n",
    "    n=int(input())\n",
    "    \n",
    "def(n):\n",
    "    "
   ]
  }
 ],
 "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
}