18-june-2019.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "YES\n"
     ]
    }
   ],
   "source": [
    "# perfect number or not\n",
    "n=int(input())\n",
    "c=0\n",
    "for i in range(1,n):\n",
    "    if(n%i==0):\n",
    "        c=c+i\n",
    "if c==n:\n",
    "    print(\"YES\")\n",
    "else:\n",
    "    print(\"NO\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# count digit sum\n",
    "s=input()\n",
    "c=0\n",
    "c1=0\n",
    "for i in s:\n",
    "    k=ord(i)\n",
    "    if ((k>=ord('a') and k<=ord('z')) or ((k>=ord('A') and k<=ord('Z')))):\n",
    "        c=c+1\n",
    "    elif k>=ord('0') and k<=ord('9'):\n",
    "        c1=c1+1\n",
    "print(c,c1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "count(...)\n",
      "    S.count(sub[, start[, end]]) -> int\n",
      "    \n",
      "    Return the number of non-overlapping occurrences of substring sub in\n",
      "    string S[start:end].  Optional arguments start and end are\n",
      "    interpreted as in slice notation.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help (str.count)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# function todetermine if a number is perfect or not\n",
    "def isspecialnumber (n, p):\n",
    "    if numberprimefactors (n) >= p:\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "\n",
    "# function to check if number is prime\n",
    "def isprime(n):\n",
    "    flag =1\n",
    "    if n==2:\n",
    "        return True\n",
    "    for i in range (2,n//2+1):\n",
    "        if n%i==0:\n",
    "            flag = 0\n",
    "            return False\n",
    "    if flag ==1:\n",
    "        return True\n",
    "isprime(11)\n",
    "        \n",
    "#function to determine number of prime factors for a given number\n",
    "\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",
    "isspecialnumber(9, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Highest remainder\n",
    "write a program to find a natural number that is smaller than N thats gives the highest remainder\n",
    "when divided by that number\n",
    "if there is more than one number print smallest number\n",
    "\n",
    "\n",
    "N\n",
    "highest = 0\n",
    "x<N and n% x == highest\n",
    "\n",
    "10\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "8\n",
      "7\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "def highestremainder(n):\n",
    "    hr = 0\n",
    "    v=n\n",
    "    for i in range (n-1,n//2,-1):\n",
    "        r = n%i\n",
    "        if r > hr:\n",
    "            hr = r\n",
    "            v = i\n",
    "        print(v)\n",
    "highestremainder(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "t1 = ()<br>\n",
    "li = []\n",
    "\n",
    "Difference between tuples and lists<br>\n",
    "\n",
    "lists are mutable - can be changes / modified<br>\n",
    "- used to access,MOdify,add,Delete data<br>\n",
    "\n",
    "Tuples are inmutable - cant be changed once initialised<br>\n",
    "- used to access data only<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = (1, 2, 3, 4)\n",
    "\n",
    "t1[3] # Accessing the fourth element\n",
    "\n",
    "# Accessing all elements from middle to last\n",
    "t1[len(t1)//2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "It works on the concept of set <br>\n",
    "Unique data\n",
    "\n",
    "keys, values<br>\n",
    "\n",
    "- key is unique identifier for a value <br>\n",
    "- value is a data that can be accessed with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "di = {\"k1\":\"value1\", \"k2\": \"value2\"}\n",
    "\n",
    "di[\"k2\"]  # Accessing the value with key \"k2\"\n",
    "di.keys()  # returns list of all keys\n",
    "di.values() #returns list of all values\n",
    "di.items()  # returns list of tuples of keys and values\n",
    "di[\"k3\"]= \"value3\" # adding an element to the dictionary\n",
    "di['k3']=\"value4\" # updating an element\n",
    "di.pop(\"k3\") # removing a element\n",
    "\"k3\" in di  #search paticular item in dictionary\n",
    "\"value1\" in di\n",
    "\n",
    "#di"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contacts Application\n",
    "- Add Contact\n",
    "- Search for Contact\n",
    "- list all contact\n",
    "    - name1 : phone1\n",
    "    - name2 :phone2\n",
    "- Modify Contact\n",
    "- Remove Contact\n",
    "- import contacts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name1 contact added\n"
     ]
    }
   ],
   "source": [
    "#add contacts\n",
    "contacts = {}\n",
    "\n",
    "def addcontact(name, phone):\n",
    "    #verify that the contact doesnot already exist\n",
    "    if name not in contacts:\n",
    "        contacts[name] = phone\n",
    "        print(\"%s contact added\" % name)\n",
    "    else:\n",
    "        print(\"contact %s already exist\"  % name)\n",
    "    return\n",
    "addcontact(\"name1\",\"12345678\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " name10 - does not exit\n"
     ]
    }
   ],
   "source": [
    "# search contacts\n",
    "def searchcontacts(name):\n",
    "    if name in contacts:\n",
    "        print(name,\":\",contacts[name])\n",
    "    else:\n",
    "        print(\" %s - does not exit\" % name)\n",
    "    return\n",
    "searchcontacts(\"name10\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 added successfully\n"
     ]
    }
   ],
   "source": [
    "# new contacts is given in dictionary\n",
    "# Merge new contacts with existing contacts\n",
    "def importcontact(newcontacts):\n",
    "    contacts.update(newcontacts)\n",
    "    print(len(newcontacts.keys()), \"added successfully\")\n",
    "    return\n",
    "newcontacts = {\"name 2\" : 9873553623, \"name 3\" : 9866775837}\n",
    "importcontact(newcontacts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name1 contact modified\n"
     ]
    }
   ],
   "source": [
    "# modify contact\n",
    "def addcontact(name, phone):\n",
    "    #verify that the contact doesnot already exist\n",
    "    if name in contacts:\n",
    "        contacts[name] = phone\n",
    "        print(\"%s contact modified\" % name)\n",
    "    else:\n",
    "       print(\"contact %s already exits \"  % name)\n",
    "    return\n",
    "addcontact(\"name1\",\"9877366355\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Packages and Modules\n",
    "\n",
    "**Package** -> Collection of modules(Python file)<br>\n",
    "**Sub Packages** -> <br>\n",
    "\n",
    "**Module**  -> A Single Python File Containing Functions<br>\n",
    "\n",
    "package-> Subpacages-> Modules -> Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "112"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math # import math functions\n",
    "math.floor(102.55)\n",
    "math.pi\n",
    "from math import floor # import only paticular function\n",
    "floor(112.22)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "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": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "121"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import floor as fl\n",
    "fl(121.23)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34 30 49 48 24 27 11 15 13 49 "
     ]
    }
   ],
   "source": [
    "# define a function to generate n random numbers in given range\n",
    "\n",
    "import random\n",
    "def generateNrandomnum(n, lb, ub):\n",
    "    for i in range(0, n):\n",
    "        print( random.randint(lb, ub),end=\" \")\n",
    "generateNrandomnum(10, 0, 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from Packages import numerical\n",
    "\n",
    "numerical.numberprimefactors(10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from Packages import numerical\n",
    "numerical.isprime(2293)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from Packages.numerical import isprime\n",
    "isprime(2293)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}