Session2_Assignment1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Write a Python Program to implement your own myreduce() function which works exactly like Python's built-in function reduce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myreduce(f, l):\n",
    "    if len(l) == 0:\n",
    "        return None\n",
    "    result = l[0]\n",
    "    for i in range(1, len(l)):\n",
    "        result = f(result, l[i])\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l=[1,2,3,4,5,6,7,8,9,10]\n",
    "myreduce(lambda x,y: x+y,l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l=[1,2,3,4,5,6,7,8,9,10]\n",
    "myreduce(lambda x,y: x*y,l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.2 Write a Python program to implement your own myfilter() function which works exactly like Python's built-in function filter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfilter(f, l):\n",
    "    result=[]\n",
    "    for i in range(len(l)):\n",
    "        if f(l[i]):\n",
    "            result.append(l[i])\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[1,2,3,4,5,6,7,8,9,10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 9]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfilter(lambda x: x%3==0, l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Implement List comprehensions to produce the following lists.\n",
    "##   Write List comprehensions to produce the following Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'C', 'A', 'D', 'G', 'I', 'L', 'D']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i for i in 'ACADGILD']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['x', 'xx', 'xxx', 'xxxx', 'y', 'yy', 'yyy', 'yyyy', 'z', 'zz', 'zzz', 'zzzz']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i*j for i in 'xyz' for j in range(1,5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['x', 'y', 'z', 'xx', 'yy', 'zz', 'xxx', 'yyy', 'zzz', 'xxxx', 'yyyy', 'zzzz']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i*j for i in range(1,5) for j in 'xyz']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2], [3], [4], [3], [4], [5], [4], [5], [6]]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[[i+j] for i in range(1,4) for j in range(1,4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 1), (2, 1), (3, 1), (1, 2), (2, 2), (3, 2), (1, 3), (2, 3), (3, 3)]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(j,i) for i in range(1,4) for j in range(1,4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8]]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[[i + j for j in [0, 1, 2, 3]] for i in range(2, 6)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.Implement a function longestWord() that takes a list of words and returns the longest one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Implement a function longestWord() that takes a list of words and returns the longest one of first occurance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[]\n",
    "def longestWord(words):\n",
    "    l=words.split()\n",
    "    v_index,v_length=0,len(l[0])\n",
    "    for i in range(1,len(l)):\n",
    "        if len(l[i]) > v_length:\n",
    "            v_length=len(l[i])\n",
    "            v_index = i\n",
    "    return l[v_index] \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "longestWord(\"Hello Mr Aneel Kumar\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Implement a function longestWord() that takes a list of words and returns the longest one of last occurance  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[]\n",
    "def longestWord(words):\n",
    "    l=words.split()\n",
    "    v_index,v_length=0,len(l[0])\n",
    "    for i in range(1,len(l)):\n",
    "        if len(l[i]) >= v_length:\n",
    "            v_length=len(l[i])\n",
    "            v_index = i\n",
    "    return l[v_index] \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Kumar'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "longestWord(\"Hello Mr Aneel Kumar\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Implement a function longestWord() that takes a list of words and returns the longest one's"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def longestWord(words):\n",
    "    l=words.split()\n",
    "    v_index,v_length=0,len(l[0])\n",
    "    result=[]\n",
    "    result.append(l[0])\n",
    "    for i in range(1,len(l)):\n",
    "        if len(l[i]) > v_length:\n",
    "            v_length=len(l[i])\n",
    "            result.clear()\n",
    "            result.append(l[i])\n",
    "        elif len(l[i]) == v_length:\n",
    "            result.append(l[i])\n",
    "            v_length=len(l[i])\n",
    "    print(\"Longest Words are: \")\n",
    "    for i in result:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longest Words are: \n",
      "Hello\n",
      "Aneel\n",
      "Kumar\n"
     ]
    }
   ],
   "source": [
    "longestWord(\"Hello Mr Aneel Kumar\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 2:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  1.1 Write a Python Program(with class concepts) to find the area of the triangle using the below formula\n",
    "\n",
    "## area = (s*(s-a)*(s-b)*(s-c)) ** 0.5\n",
    "## Function to take the length of the sides of triangle from user should be defined in the parent class and function to calculate the area should be defined in subclass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parent:\n",
    "    def __init__(self,s,a,b,c):\n",
    "        self.s = s\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "        self.c = c\n",
    "        \n",
    "class Child(Parent):\n",
    "    def __init__(self,*args):\n",
    "        super(Child,self).__init__(*args)\n",
    "        \n",
    "    def length(self):\n",
    "        area = (self.s * (self.s - self.a) * (self.s-self.b) * (self.s - self.c)) * 0.5\n",
    "        return area \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1680.0"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p=Parent(10,2,3,4)\n",
    "c=Child(10,2,3,4)\n",
    "c.length()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Write a function filter_long_words() that takes a list of words and an integer n and returns the list of words that are longer than n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_long_words(words,n):\n",
    "    l=words.split()\n",
    "    v_word_cnt = [(i,len(i)) for i in l]\n",
    "    v_cnt = 0\n",
    "    print(\"Words Longer than given length: \")\n",
    "    for i in v_word_cnt:\n",
    "        if i[1] > n:\n",
    "            v_cnt = v_cnt + 1\n",
    "            print(i[0])\n",
    "    if v_cnt ==0:\n",
    "        print(\"There are no words in the given list longer than the mentioned length\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Words Longer than given length: \n",
      "There are no words in the given list longer than the mentioned length\n"
     ]
    }
   ],
   "source": [
    "filter_long_words(\"Hello Mr Aneel Kumar Yenikapati\",10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Words Longer than given length: \n",
      "Hello\n",
      "Mr\n",
      "Aneel\n",
      "Kumar\n",
      "Yenikapati\n"
     ]
    }
   ],
   "source": [
    "filter_long_words(\"Hello Mr Aneel Kumar Yenikapati\",0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Words Longer than given length: \n",
      "Hello\n",
      "Aneel\n",
      "Kumar\n",
      "Yenikapati\n"
     ]
    }
   ],
   "source": [
    "filter_long_words(\"Hello Mr Aneel Kumar Yenikapati\",2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Write a Python program using function concept that maps list of words into a list of integers representing the lengths of the corresponding words\n",
    "\n",
    "## Hint: ​If a list [ ab,cde,erty] is passed on to the python function output should come as [2,3,4]\n",
    "## Here 2,3 and 4 are the lengths of the words in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "def length_of_words(list_in):\n",
    "    #l=[ 'ab','cde','erty']\n",
    "    result = [len(i) for i in list_in]\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4]"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length_of_words([\"ab\",\"cde\",\"erty\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Write a Python function which takes a character (i.e. a string of length 1) and returns True if it is a vowel, False otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vowel_check(input_char):\n",
    "    if input_char.lower() in('a','e','i','o','u'):\n",
    "        return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vowel_check('Z')\n",
    "vowel_check('A')"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}