27-June-19.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# string reverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cba\n",
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "s=\"abc\"\n",
    "print(s[::-1])\n",
    "for i in s:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c\n",
      "b\n",
      "a\n",
      "abc \n",
      "\n"
     ]
    }
   ],
   "source": [
    "x=reversed(s)\n",
    "for i in x:\n",
    "    print(i)\n",
    "print(s,)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# averages of numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22 3 12\n",
      "12.333333333333334\n"
     ]
    }
   ],
   "source": [
    "s=input()\n",
    "x=list(map(int,s.split()))\n",
    "x1=x[0]\n",
    "y=x[1]\n",
    "z=x[2]\n",
    "def avges(x1,y,z):\n",
    "    s=0\n",
    "    c=0\n",
    "    for i in (x1,y,z):\n",
    "        s=s+i\n",
    "        c=c+1\n",
    "        avg=s/c\n",
    "    return avg\n",
    "print(avges(x1,y,z))    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kth Lowest frequency"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to print all combinations of pairs of integers in a unique list\n",
    "#### >[1,2,3]=combinations=(1,2),(1,3),(2,3)=formula is 3C2==3!/((3-2)!*2!)\n",
    "#### >[1,2,3,4]==1,2 1,3 1,4 2,3 2,4 3,4 combinations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "1 2 4\n",
      "1 2 5\n",
      "1 3 4\n",
      "1 3 5\n",
      "1 4 5\n",
      "2 3 4\n",
      "2 3 5\n",
      "2 4 5\n",
      "3 4 5\n"
     ]
    }
   ],
   "source": [
    "def combinations3(li):\n",
    "    for i in range(len(li)-1):\n",
    "        for j in range(i+1,len(li)): # for 2 combination  i+1 \n",
    "            for k in range(j+1,len(li)): #for 3 combo j+1(j before added with 1) up length of li\n",
    "                print(li[i],li[j],li[k])\n",
    "combinations3([1,2,3,4,5])  # totally we are getting 10 combinations\n",
    "        \n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n",
      "1 2 3 5\n",
      "1 2 4 5\n",
      "1 3 4 5\n",
      "2 3 4 5\n"
     ]
    }
   ],
   "source": [
    "def combo4(li):\n",
    "    for i in range(len(li)):\n",
    "        for j in range(i+1,len(li)):\n",
    "            for k in range(j+1,len(li)):\n",
    "                for k1 in range(k+1,len(li)):\n",
    "                    print(li[i],li[j],li[k],li[k1])\n",
    "combo4([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#[1,2,3]-->[1,2,3]\n",
    "def solutionmedium(li,k):\n",
    "    while True:\n",
    "        li3=differencepairs(li)\n",
    "        #print(li3)\n",
    "        if li3[0]==li3[1]:\n",
    "            break\n",
    "    if len(li3[0])>=k:\n",
    "        return sorted(li3[0],reverse=True)[k-1]\n",
    "    return -1\n",
    "def differencepairs(li):\n",
    "    cli=li[:]\n",
    "    newelements=[]\n",
    "    for i in range(len(li)-1):\n",
    "        for j in range(i+1,len(li)):\n",
    "            diff=abs(li[i]-li[j])\n",
    "            if diff not in li and diff not in newelements:\n",
    "                newelements.append(diff)\n",
    "    li.extend(newelements)\n",
    "    return [cli,li]\n",
    "li=[1,9,8,7]\n",
    "#print(differencepairs([1,9]) )\n",
    "solutionmedium(li,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 9], [1, 9, 8]]"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# function to identify differences of a ll pairs of numbers and add those diffence to same list\n",
    "#it returns updated list and original list\n",
    "def differencepairs(li):\n",
    "    cli=li[:]\n",
    "    newelements=[]\n",
    "    for i in range(len(li)-1):\n",
    "        for j in range(i+1,len(li)):\n",
    "            diff=abs(li[i]-li[j])\n",
    "            if diff not in li and diff not in newelements:\n",
    "                newelements.append(diff)\n",
    "    li.extend(newelements)\n",
    "    return [cli,li]\n",
    "#li=[1,9,8,7]\n",
    "differencepairs([1,9])    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "0\n",
      "0\n",
      "motu\n",
      "13\n",
      "26\n",
      "motu\n"
     ]
    }
   ],
   "source": [
    "n=int(input())\n",
    "c1=0\n",
    "c2=0\n",
    "c=n\n",
    "for i in (0,n):\n",
    "    c1+=i\n",
    "    #print(c1)\n",
    "    c2+=i*2\n",
    "    #print(c2)\n",
    "    if (c1+c2<n & c<i):\n",
    "        print(\"patlu\")\n",
    "    else:\n",
    "        print(\"motu\")\n",
    "        \n",
    "    \n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solutionmedium(li,k):\n",
    "    while True:\n",
    "        li3=differencepairs(li)\n",
    "        #print(li3)\n",
    "        if li3[0]==li3[1]:\n",
    "            break\n",
    "    if len(li3[0])>=k:\n",
    "        return sorted(li3[0],reverse=True)[k-1]\n",
    "    return -1\n",
    "def differencepairs(li):\n",
    "    cli=li[:]\n",
    "    newelements=[]\n",
    "    for i in range(len(li)-1):\n",
    "        for j in range(i+1,len(li)):\n",
    "            diff=abs(int(li[i])-int(li[j]))\n",
    "            if diff not in li and diff not in newelements:\n",
    "                newelements.append(str(diff))\n",
    "    li.extend(newelements)\n",
    "    return [cli,li]\n",
    "#li=[1,9,8,7]\n",
    "#print(differencepairs([1,9]) )\n",
    "\n",
    "with open('data files/mediuminput.txt','r') as f:\n",
    "    t=int(f.readline())\n",
    "    for i in range(t):\n",
    "                     f.readline()\n",
    "                     li=f.readline().split()\n",
    "                     k=int(f.readline())\n",
    "                     print(solutionmedium(li,k))    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 3, 6, 9, 12, 1, 4, 7, 10, 5, 8, 11],\n",
       " [2, 3, 6, 9, 12, 1, 4, 7, 10, 5, 8, 11]]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def differencepairs1(li):\n",
    "    cli=li[:]\n",
    "    newelements=[]\n",
    "    for i in range(len(li)-1):\n",
    "        for j in range(i+1,len(li)):\n",
    "            diff=abs(int(li[i])-int(li[j]))\n",
    "            if diff not in li and diff not in newelements:\n",
    "                newelements.append((diff))\n",
    "    li.extend(newelements)\n",
    "    return [cli,li]\n",
    "li=[2,3,6,9,12,1, 4, 7, 10,5,8,11]\n",
    "differencepairs1(li)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Set-Data Structure in a python \n",
    "### {},-->unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4, 6, 7, 8, 10}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a={1,3,4,6,7,8,7,3}# display only unique elements\n",
    "a.add(10)#to add new value\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accesing elements in set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 4 6 7 8 10 "
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    print(i,end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4, 6, 7, 8, 10, 12, 43, 45, 55, 90, 99}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b={7,8,99,55,43}\n",
    "x=[1,90,55,45]\n",
    "a.update(b,x) #adding multiple elements\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4, 6, 7, 8, 10, 12, 43, 45, 55, 99}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.discard(90)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7}\n",
      "{2}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{2}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a={1,4,2,6}\n",
    "b={3,5,7,2}\n",
    "c={111,22}\n",
    "print(a.union(b))#A U B = B U A\n",
    "b.union(a)\n",
    "print(a.intersection(b))#a intersection b== b intersection  a\n",
    "b.intersection(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.isdisjoint(c)# a c elements are not same then it return true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 4, 6}\n",
      "{3, 5, 7}\n"
     ]
    }
   ],
   "source": [
    "print(a - b)#elements of a which are not in b,common elements in b are removed and print remains of a\n",
    "print(b - a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 6]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(a) # display all elements in sorting order in alist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4, 5, 6, 7}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a={1,4,2,6}\n",
    "b={3,5,7,2}\n",
    "a ^ b     #elements in a or b except common of both"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=set()# creates an empty set\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "li=[1,2,3,4,2,1,2,3,4]\n",
    "u=set(li)\n",
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functional programming\n",
    "### Ex:procedural:c\n",
    "### object oriented:java,python\n",
    "#### scripting:php,python,javascript,shell\n",
    "### functional:python,haskell,scala\n",
    "### logic:prolog,lisp\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list of n natural numbers\n",
    "def nat(n):\n",
    "    li=[]\n",
    "    for i in range(1,n+1):\n",
    "        li.append(i)\n",
    "    return li\n",
    "nat(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "li=[i for i in range(1,11)]   # BY list comprehension\n",
    "li\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]\n",
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Apply list comprehension to store the cubes of n natural numbers\n",
    "l=[i**3 for i in range(1,11)] # for cubes\n",
    "l2=[i*2 for i in range(1,6)]\n",
    "print(l)\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 1.4142135623730951, 1.7320508075688772, 2.0, 2.23606797749979]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sqrt as r\n",
    "l2=[r(i) for i in range(1,6)]  #find the sqrt values from 1 to 5\n",
    "l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "print([x for x in range(1,11) if x%2==0]) #All  even numbers from 1,10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# function to calculate the factorial\n",
    "def fact(n):\n",
    "    if n==0 or n==1: #recursion\n",
    "        return 1\n",
    "    return n*fact(n-1)\n",
    "fact(5)\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 6, 24, 120]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n=5\n",
    "factlist=[fact(i) for i in range(1,n+1)] # list comprehension factorial\n",
    "factlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 6, 10, 15, 21]\n"
     ]
    }
   ],
   "source": [
    "# store  cumulative sum of numbers till n in a list\n",
    "#n=3,[1,3,6] -->cumulative sum\n",
    "n=6\n",
    "cumsum=[sum(range(1,i+1)) for i in range(1,n+1)]\n",
    "print(cumsum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1972, 1976, 1980, 1984, 1988, 1992, 1996, 2000, 2004, 2008, 2012, 2016]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#function to store only leap yeares in a gievn time period by using list comprehension\n",
    "st=1970\n",
    "et=2019\n",
    "leap=[i for i in range(st,et+1) if i%4==0 and i%100!=0 or i%400==0]\n",
    "leap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[None, None, None, None, None]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "li=[1,2,3,3,2,44,5]\n",
    "unique=[]\n",
    "u2=[]\n",
    "unique=[for i in range(0,len(li)-1) if sorted()]\n",
    "unique=[u2.append(i) for i in li if i not in u2 ]\n",
    "unique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterators\n",
    "### Iterable-Strings,Lists,Tuples,sets,dictionaries\n",
    "### convert Iterable to iterator-->iter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n"
     ]
    }
   ],
   "source": [
    "it=iter('python')\n",
    "print(next(it))\n",
    "print(next(it))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generator \n",
    "### generator is Function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "512"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def generator():\n",
    "    n=2\n",
    "    yield n #yield return value at this time\n",
    "    n=n**3\n",
    "    yield n\n",
    "    n=n**3\n",
    "    yield n\n",
    "a=generator()\n",
    "next(a)\n",
    "next(a)  \n",
    "next(a) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35184372088832"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def generator():\n",
    "    n=2\n",
    "    for i in range(1,5):\n",
    "        n**=3\n",
    "        yield n\n",
    "a=generator()\n",
    "next(a)\n",
    "b=next(a)**2\n",
    "b*=next(a)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "512\n",
      "134217728\n",
      "2417851639229258349412352\n"
     ]
    }
   ],
   "source": [
    "def generator():\n",
    "    n=2\n",
    "    for i in range(1,5):\n",
    "        n**=3\n",
    "        yield n\n",
    "a=generator()\n",
    "for i in range(1,5):\n",
    "    print(next(a))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}