14-jun-2019.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem solving and programming\n",
    "\n",
    "### Day Objectives\n",
    "\n",
    "- Python Data Structures\n",
    "- Python Data Structers\n",
    "    - Lists\n",
    "    - Tuples\n",
    "    - Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "978"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Python Data Structers\n",
    "# Lists\n",
    "\n",
    "li = [123, 978, 654]\n",
    "li     #access the entire list\n",
    "li[1]  # access a element with index in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-10, 234, -2, -1, 1, 9, 234, 456, 789] "
     ]
    }
   ],
   "source": [
    "li[1:]  # string slicing to access second element to last element\n",
    "\n",
    "\n",
    "li[::-1] # accessing the list in reverse list\n",
    "\n",
    "li\n",
    "\n",
    "li[::2] # accessing even index elements\n",
    "\n",
    "li[1::2] # accessing odd index elements\n",
    "li\n",
    "li[1::-2] \n",
    "li\n",
    "\n",
    "# list can be accessed , manipulated in two different types\n",
    "  # Direct Referencing - [index]\n",
    "  # Direct REferencing - Through functions\n",
    "\n",
    "\n",
    "li.append(345) # adding an element to end of a array\n",
    "li\n",
    "li.insert(1, 234) # adding an element ata a\n",
    "\n",
    "li\n",
    "\n",
    "\n",
    "li.pop()\n",
    "li\n",
    "\n",
    "li2 = [234, 456, 789]\n",
    "li.extend(li2)\n",
    "print (li,end=\" \")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(li)  # sum of all elements in a list\n",
    "max(li)  # Maximum element in a list\n",
    "len(li)  # number of elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# average of list elements\n",
    "\n",
    "li=[10,12,14,16,18,20]\n",
    "average = sum(li[0::2])/len(li[0::2]) # even index average\n",
    "average1 = sum(li[1::2])/len(li[1::2]) # odd index\n",
    "average1\n",
    "\n",
    "# average of alternate elements\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Function to identify the second largest element\n",
    "\n",
    "k=[1,4,3,2,7,8,5,6]\n",
    "k.sort() \n",
    "k[-2]\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# function that return the nth element\n",
    "\n",
    "def largest(li,n):\n",
    "    li.sort()\n",
    "    return li[-n]\n",
    "largest(li,5)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Function to search for a data in list\n",
    "# search for the key in the list return the key,otherwise return -1 key not found\n",
    "def linearsearch(li,key):\n",
    "        \n",
    "    for ele in li:\n",
    "        if ele==key:\n",
    "            return li.index(ele)\n",
    "    return (\"key not matched\")\n",
    "linearsearch([1,3,56,7,35,11,22,32,544,664,66,2,567,89,77],32)\n",
    "    \n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter a string = bharat sunil\n",
      "enter a character = a\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Function to count the occurances of a character\n",
    "# \"python programming\", m-> 2\n",
    "def occurance (li,char):\n",
    "    count =0\n",
    "    for i in li:\n",
    "        if i==char:\n",
    "            count = count+1\n",
    "    return count\n",
    "a=input(\"enter a string = \")\n",
    "b=input('enter a character = ')\n",
    "occurance(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"1 2 3 4 5 6\"\n",
    "li = s.split()\n",
    "numberlist=[]\n",
    "for i in li:\n",
    "    numberlist.append(int(i))\n",
    "numberlist\n",
    "\n",
    "# n = int(input())\n",
    "# s = input()\n",
    "# li = s.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Number Closest to zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n"
     ]
    }
   ],
   "source": [
    "li = [-1,-3,-2,2,3,1]\n",
    "li.sort()\n",
    "\n",
    "pl =[]\n",
    "\n",
    "for i in li:\n",
    "    pl.append(abs(i))\n",
    "pl.sort()\n",
    "if -pl[0] in li:\n",
    "    print(-pl[0])\n",
    "else:\n",
    "    print(pl[0])\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Farhest from zero\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n"
     ]
    }
   ],
   "source": [
    "li = [-1,-2,1,-10,9]\n",
    "li.sort()\n",
    "pl=[]\n",
    "for i in li:\n",
    "    pl.append(abs(i))\n",
    "    \n",
    "pl.sort()\n",
    "if pl[-1] in li:\n",
    "    print(pl[0])\n",
    "else:\n",
    "    print(-pl[0]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### you are given three numbers, a,b,c\n",
    "- write the program to find largest number\n",
    "- which is less than or equal to c and leaves\n",
    "- remainder b when divided by a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print the value of expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = int(input())\n",
    "def semsqaresnaturalnumbers(n):\n",
    "    sum = 0\n",
    "    for i in range (1,n+1):\n",
    "        sum=sum+i**2\n",
    "    return sum\n",
    "semsqaresnaturalnumbers(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# my logic\n",
    "def threenum(a,b,c):\n",
    "    c=c-1\n",
    "    if c%a==b:\n",
    "        \n",
    "        return c\n",
    "    return -1\n",
    "threenum(3,2,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#sir solution\n",
    "def threenum(a,b,c):\n",
    "    for i in range (c,a-1,-1):\n",
    "        if i%a==b:\n",
    "            return i\n",
    "    return -1\n",
    "threenum(3,2,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "YES\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'inam'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1=\"mani\"\n",
    "s2=\"inam\"\n",
    "if s2==s1[::-1]:\n",
    "    print(\"YES\")\n",
    "else:\n",
    "    print(\"NO\")\n",
    "r"
   ]
  },
  {
   "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
}