Subjective Assignment - 3 - Python Class.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Write the Python class to convert an integer to a roman numeral?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MMMMCDLXXV\n"
     ]
    }
   ],
   "source": [
    "def roman(num):\n",
    "    val = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]\n",
    "    \n",
    "    rom = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']\n",
    "    \n",
    "    i = 0\n",
    "    roman = ''\n",
    "    while num > 0:\n",
    "        if num < val[i]:\n",
    "            i += 1\n",
    "            continue\n",
    "        else:\n",
    "            r = num//val[i]\n",
    "            roman += rom[i]*r\n",
    "            num -= val[i]*r\n",
    "            i += 1\n",
    "    return roman\n",
    "print(roman(4475))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2 Write the Python class to convert a Roman numeral to an integer?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4475\n"
     ]
    }
   ],
   "source": [
    "def number(roman):\n",
    "    val = [1000, 500, 100, 50, 10, 5, 1, 0]\n",
    "    \n",
    "    rom = ['M', 'D', 'C', 'L', 'X', 'V', 'I', ' ']\n",
    "    s = 0\n",
    "    roman += ' '\n",
    "    for i in range(len(roman) - 1):\n",
    "        l = val[rom.index(roman[i])]\n",
    "        if l < val[rom.index(roman[i+1])]:\n",
    "            s -= l\n",
    "        else:\n",
    "            s += l\n",
    "    return s\n",
    "print(number('MMMMCDLXXV'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Write the Python class to find the validity of the string of the\n",
    "parentheses, '(', ')', '{', '}', '[' and '] and the brackets must be closed\n",
    "in the correct order, example - \"()\" and \"()[]{}\" are valid but \"[)\",\n",
    "\"({[)]\" and \"{{{\" are invalid.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{[]{()}} - Unbalanced\n",
      "((() - Unbalanced\n"
     ]
    }
   ],
   "source": [
    "class python:\n",
    "    \n",
    "    def check(expression): \n",
    "\n",
    "        open_tup = tuple('({[') \n",
    "        close_tup = tuple(')}]') \n",
    "        map1 = dict(zip(open_tup, close_tup)) \n",
    "        queue = [] \n",
    "\n",
    "        for i in expression: \n",
    "            if i in open_tup: \n",
    "                queue.append(map1[i]) \n",
    "            elif i in close_tup: \n",
    "                if not queue : \n",
    "                    return \"Unbalanced\"\n",
    "        if not queue: \n",
    "            return \"Balanced\"\n",
    "        else: \n",
    "            return \"Unbalanced\"\n",
    "\n",
    "        \n",
    "        \n",
    "string1 = \"{[]{()}}\"\n",
    "print(string1, \"-\", python.check(string1)) \n",
    "\n",
    "string2 = \"((()\"\n",
    "print(string2,\"-\",python.check(string2)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Write the Python class to get all possible unique subsets from a set\n",
    "of distinct integers?\n",
    "\n",
    "    Input - [4, 5, 6]\n",
    "    Output - [[], [6], [5], [5, 6], [4], [4, 6], [4, 5], [4, 5, 6]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[], [4], [5], [6], [4, 5], [4, 6], [5, 6], [4, 5, 6]]\n"
     ]
    }
   ],
   "source": [
    "class subset:\n",
    "    def unique(list1):\n",
    "        from itertools import combinations\n",
    "        l = []\n",
    "        for i in range(len(list1) + 1):\n",
    "            p = combinations(list1, i)\n",
    "            for j in p:\n",
    "                l.append(list(j))\n",
    "        return l\n",
    "print(subset.unique([4, 5, 6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Write the Python class to find a pair of elements (indices of the two\n",
    "numbers) from a given array whose sum equals the specific target\n",
    "number?\n",
    "\n",
    "    Input: numbers- [10,20,10,40,50,60,70], target=50\n",
    "    Output- 3, 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index1=2, index2=3\n"
     ]
    }
   ],
   "source": [
    "class py_solution:\n",
    "    def twoSum(self, nums, target):\n",
    "        lookup = {}\n",
    "        for i, num in enumerate(nums):\n",
    "            if target - num in lookup:\n",
    "                return (lookup[target - num], i )\n",
    "            lookup[num] = i\n",
    "print(\"index1=%d, index2=%d\" % py_solution().twoSum((10,20,10,40,50,60,70),50))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q6. Write the Python class to find the three elements that sum to zero\n",
    "from the set of n real numbers?\n",
    "\n",
    "    Input array- [-25, -10, -7, -3, 2, 4, 8, 10]\n",
    "    Output - [[-10, 2, 8], [-7, -3, 10]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-10, 2, 8], [-7, -3, 10]]\n"
     ]
    }
   ],
   "source": [
    "class py_solution:\n",
    "    def threeSum(self, nums):\n",
    "        nums, result, i = sorted(nums), [], 0\n",
    "        while i < len(nums) - 2:\n",
    "            j, k = i + 1, len(nums) - 1\n",
    "            while j < k:\n",
    "                if nums[i] + nums[j] + nums[k] < 0:\n",
    "                    j += 1\n",
    "                elif nums[i] + nums[j] + nums[k] > 0:\n",
    "                    k -= 1\n",
    "                else:\n",
    "                    result.append([nums[i], nums[j], nums[k]])\n",
    "                    j, k = j + 1, k - 1\n",
    "                    while j < k and nums[j] == nums[j - 1]:\n",
    "                        j += 1\n",
    "                    while j < k and nums[k] == nums[k + 1]:\n",
    "                        k -= 1\n",
    "            i += 1\n",
    "            while i < len(nums) - 2 and nums[i] == nums[i - 1]:\n",
    "                i += 1\n",
    "        return result\n",
    "\n",
    "print(py_solution().threeSum([-25, -10, -7, -3, 2, 4, 8, 10]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7. Write the Python class to implement pow(x, n)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "class python:\n",
    "    def pow(x, n):\n",
    "        return x**n\n",
    "print(python.pow(2, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8. Write the Python class which has two methods get_String and\n",
    "print_String. get_String accept the string from the user and \n",
    "print_String print the string in upper case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EnterShreya Gupta\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'SHREYA GUPTA'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class python:\n",
    "    def __init__(self):\n",
    "        self.str1 = \"\"\n",
    "        \n",
    "    def get_String(self):\n",
    "        self.str1 = input('Enter')\n",
    "    def print_String(self):\n",
    "        return self.str1.upper()\n",
    "\n",
    "string = python()\n",
    "string.get_String()\n",
    "string.print_String()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Write the Python class named Rectangle constructed by a length\n",
    "and width and the method which will compute the area of the\n",
    "rectangle?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n"
     ]
    }
   ],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, l, b):\n",
    "        self.l = l\n",
    "        self.b = b\n",
    "    \n",
    "    def area(self):\n",
    "        return self.l * self.b\n",
    "    \n",
    "rect = Rectangle(10, 20)\n",
    "print(rect.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q10. Write the Python class named Circle constructed by the radius\n",
    "and two methods which will compute the area and perimeter of\n",
    "the circle?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area 12.571428571428571\n",
      "Perimeter 12.571428571428571\n"
     ]
    }
   ],
   "source": [
    "class Circle:\n",
    "    def __init__(self, r):\n",
    "        self.r = r\n",
    "    \n",
    "    def area(self):\n",
    "        return 22/7 * self.r ** 2\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 22/7 * 2 * self.r\n",
    "\n",
    "circle = Circle(2)\n",
    "print('Area', circle.area())\n",
    "print('Perimeter', circle.perimeter())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. Write the Python program to get the class name of an instance in\n",
    "Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cycle\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "x = itertools.cycle('ABCD')\n",
    "print(type(x).__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q12. Write the Python program to count the number of students of\n",
    "individual class?\n",
    "\n",
    "    Sample dataclasses = (\n",
    "    ('V', 1),\n",
    "    ('VI', 1),\n",
    "    ('V', 2),\n",
    "    ('VI', 2),\n",
    "    ('VI', 3),\n",
    "    ('VII', 1),\n",
    "    )\n",
    "    Expected OutputCounter({'VI': 3, 'V': 2, 'VII': 1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'VI': 3, 'V': 2, 'VII': 1})\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "classes = (\n",
    "    ('V', 1),\n",
    "    ('VI', 1),\n",
    "    ('V', 2),\n",
    "    ('VI', 2),\n",
    "    ('VI', 3),\n",
    "    ('VII', 1),\n",
    ")\n",
    "students = Counter(class_name for class_name, no_students in classes)\n",
    "print(students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Great Job!"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}