12-june-2019.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem Solving and Programming\n",
    "#### Date 12 june 2019\n",
    " \n",
    " ### Day Objectives\n",
    "- String Slicing\n",
    "- Functions in Python\n",
    "- Basic Problems related to conditional statements using functions\n",
    "- Iteration in python\n",
    "- Python data structures - Lists,Tuples and dictionaries\n",
    "- Basic operations on data structures\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nohtyp'"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = \"python\"\n",
    "\n",
    "s1 \n",
    "\n",
    "s1 [0]               # Accessing of the first charcter in a string\n",
    "s1 [1]               # Accessing of the second charcter in a string\n",
    "s1 [5]               #use anyone to know last digit\n",
    "s1 [-1]\n",
    "s1[len(s1)-1]        # use this for long strings and u dont know the the length of the string \n",
    "s1 [-2]              # Accessing the last but one character \n",
    "s1[0:5]              # Accessing the two letters\n",
    "\n",
    "s1[-2:]              # Accessing the last two letters in a string if string is long (dont know string size)\n",
    "s1[4:]               # Another way to get last two letters if you know the string size i.e, 5\n",
    "\n",
    "# Accessing all characters except first and last character\n",
    "s1 [1:-1]\n",
    "\n",
    "# Accessing the middle character in a string\n",
    "s1[len(s1)//2]\n",
    "\n",
    "s1[-1::-1] #reverse a string\n",
    "\n",
    "s1[-1:-3:-1] #Accessing last two characters in reverse order\n",
    "\n",
    "\n",
    "# reverse the middle two characters in an even length string\n",
    "\n",
    "   # s1[len(s1)//2:len(s1)//2-2:-1]\n",
    "    \n",
    "# Accessing alternate characters in a string\n",
    "s1[::2]\n",
    "\n",
    "# Accessing alternate characters in reverse order\n",
    "s1[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nohtyP'"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Function to reverse a string\n",
    "def reversestring(s):\n",
    "    return s[::-1]\n",
    "reversestring(\"Python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Function to check if string is a palindrome\n",
    "def palindrome(s):\n",
    "    if s == s[::-1]:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "palindrome(\"tot\") #Exmple of palindrome is racecar,123321,pop...etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if given year is a leap year\n",
    "def isleapyear(year):\n",
    "    if year % 4 == 0: \n",
    "     return True\n",
    "    return False\n",
    "isleapyear (2017)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Function to count the number of digits ina given number\n",
    "def leapyearnum(count):\n",
    "    return len(str(count))\n",
    "leapyearnum (12345)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function to identify the greatest of 4 numbers\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type (True) #boolean data type\n",
    "type (12)   #int data type\n",
    "type (\"python\")   #String data type\n",
    "type (12.3)   #Float data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "a = 12\n",
    "print(a,type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "a = \"hello\"\n",
    "print (a,type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print (a,type(a)) #python is a line by line executed language"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "10\n",
      "6\n",
      "0\n",
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'gggggg'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(2 or 7)\n",
    "print(7 and 10)\n",
    "print(-7 and 6)\n",
    "print(0 and 4)\n",
    "print (True + True)\n",
    "\"g\"*6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not zero\n"
     ]
    }
   ],
   "source": [
    "if 0:\n",
    "    print(\"zero\")\n",
    "else:\n",
    "    print(\"not zero\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-21-b62975cae4c7>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-21-b62975cae4c7>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    while 0=0:\u001b[0m\n\u001b[1;37m           ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "i=0\n",
    "while 0=0:\n",
    "    print(i)\n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iteration\n",
    "- for\n",
    "- while"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 "
     ]
    }
   ],
   "source": [
    "# Function to print n natural numbers\n",
    "def printn(n):\n",
    "    for counter in range (1, n+1):\n",
    "        print(counter, end=\" \")\n",
    "        \n",
    "    return \n",
    "\n",
    "printn(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 "
     ]
    }
   ],
   "source": [
    "def printnnum(n):\n",
    "    counter = 1\n",
    "    while counter<=n:\n",
    "        print(counter,end=\" \")\n",
    "        counter=counter+1  \n",
    "    return\n",
    "\n",
    "printnnum(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "30\n",
      "36\n",
      "42\n",
      "48\n",
      "54\n",
      "60\n",
      "66\n",
      "72\n",
      "78\n",
      "84\n",
      "90\n",
      "96\n",
      "102\n",
      "108\n",
      "114\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "# Function to print all numbers divisible by 6 and not a factor of 100 in a given range(lb,ub) inclusive\n",
    "\n",
    "def divisible(lb,ub):\n",
    "\n",
    "    for t in range(lb,ub+1):\n",
    "        if (t % 6 == 0 and 100 % t !=0):\n",
    "            print(t)\n",
    "            \n",
    "          \n",
    "divisible(22,122)    \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'isprime' 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-16-361823259bcc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 15\u001b[1;33m \u001b[0mavgNprimes\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     16\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-16-361823259bcc>\u001b[0m in \u001b[0;36mavgNprimes\u001b[1;34m(n)\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[0mseqcount\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m     \u001b[1;32mwhile\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mprimecount\u001b[0m \u001b[1;33m<\u001b[0m \u001b[0mn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m         \u001b[1;32mif\u001b[0m \u001b[0misprime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mseqcount\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      9\u001b[0m             \u001b[0mprimecount\u001b[0m\u001b[1;33m+=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m             \u001b[0msum\u001b[0m\u001b[1;33m+=\u001b[0m\u001b[0mseqcount\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'isprime' is not defined"
     ]
    }
   ],
   "source": [
    "# average of first N prime members\n",
    "\n",
    "def avgNprimes(n):\n",
    "    primecount = 0\n",
    "    sum = 0\n",
    "    seqcount = 2\n",
    "    while(primecount < n):\n",
    "        if isprime(seqcount):\n",
    "            primecount+=1\n",
    "            sum+=seqcount\n",
    "            seqcount+= 1\n",
    "    return sum/n\n",
    "    \n",
    "    \n",
    "avgNprimes(1)\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 9 8 7 6 5 4 3 2 1 "
     ]
    }
   ],
   "source": [
    "# print num in reverse order in same line\n",
    "def order(a,b):\n",
    "    for value in range(b,a-1,-1):\n",
    "         print(value, end = \" \")\n",
    "    return\n",
    "\n",
    "order(1, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15150"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# FUNCTION TO CALCULATE THE SUM OF NUMBER IN A RANGE\n",
    "\n",
    "def sumrange(start, end):\n",
    "    sum = 0\n",
    "    for i in range(start,end+1):\n",
    "        sum = sum+i\n",
    "    return sum\n",
    "sumrange(100, 200)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Function to calculate the average of given range\n",
    "def avgnum (lb,ub):\n",
    "    sum =0\n",
    "    count =0\n",
    "    for i in range (lb,ub+1):\n",
    "    \n",
    "        sum = sum+i\n",
    "   \n",
    "        count = count +1    \n",
    "    return sum/count\n",
    "\n",
    "avgnum(100, 200)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 201 303 406 510 615 721 828 936 1045 1155 1266 1378 1491 1605 1720 1836 1953 2071 2190 2310 2431 2553 2676 2800 2925 3051 3178 3306 3435 3565 3696 3828 3961 4095 4230 4366 4503 4641 4780 4920 5061 5203 5346 5490 5635 5781 5928 6076 6225 6375 6526 6678 6831 6985 7140 7296 7453 7611 7770 7930 8091 8253 8416 8580 8745 8911 9078 9246 9415 9585 9756 9928 10101 10275 10450 10626 10803 10981 11160 11340 11521 11703 11886 12070 12255 12441 12628 12816 13005 13195 13386 13578 13771 13965 14160 14356 14553 14751 14950 15150 "
     ]
    }
   ],
   "source": [
    "# function sum of caluculate the given range\n",
    "\n",
    "def sumofnum (lb,ub):\n",
    "    sum=0     #print the values upto final value from strating value\n",
    "    for i in range (lb,ub+1):\n",
    "        sum = sum+i\n",
    "        print (sum, end =\" \")\n",
    "    return\n",
    "sumofnum (100, 200)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15150"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# function sum of caluculate the given range\n",
    "\n",
    "def sumofnum (lb,ub):    #only print the final sum value\n",
    "    sum=0\n",
    "    for i in range (lb,ub+1):\n",
    "        sum = sum+i\n",
    "    return sum\n",
    "sumofnum (100, 200)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 98 96 94 92 90 88 86 84 82 80 78 76 74 72 70 68 66 64 62 60 58 56 54 52 50 "
     ]
    }
   ],
   "source": [
    "# Function to print reverse order\n",
    "def rorder (a,b):\n",
    "    for i in range (b,a-1,-2):\n",
    "        print (i,end = \" \")\n",
    "    return\n",
    "rorder(50,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 "
     ]
    }
   ],
   "source": [
    "# Function to print 1 to 100 numbers\n",
    "def num(lb,ub):\n",
    "    for i in range (lb, ub+1):\n",
    "        print (i,end =\" \")\n",
    "    return\n",
    "num(1,100)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 "
     ]
    }
   ],
   "source": [
    "# Function to print 1 to 100 in reverse order\n",
    "def rnum(lb,ub):\n",
    "    for i in range (ub,lb-1,-1):\n",
    "         print (i,end =\" \")\n",
    "    return\n",
    "rnum(1,50)\n",
    "    "
   ]
  },
  {
   "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
}