Python Exercise (51-60).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Exercise Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 51\n",
    "> ***Write a function to compute 5/0 and use try/except to catch the exceptions.***\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Why on earth you are dividing a number by ZERO!!\n"
     ]
    }
   ],
   "source": [
    "def divide():\n",
    "    return 5/0\n",
    "try:\n",
    "    divide()\n",
    "except ZeroDivisionError as ze:\n",
    "    print(\"Why on earth you are dividing a number by ZERO!!\")\n",
    "except Exception(err):\n",
    "    print(\"Any other exception\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 52\n",
    "> ***Define a custom exception class which takes a string message as attribute.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "89\n",
      "The error raised: Input is grater than 10\n"
     ]
    }
   ],
   "source": [
    "class CustomException(Exception):\n",
    "    \"\"\"Exception raised for custom purpose\n",
    "\n",
    "    Attributes:\n",
    "        message -- explanation of the error\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, message):\n",
    "        self.message = message\n",
    "\n",
    "\n",
    "num = int(input())\n",
    "\n",
    "try:\n",
    "    if num < 10:\n",
    "        raise CustomException(\"Input is less than 10\")\n",
    "    elif num > 10:\n",
    "        raise CustomException(\"Input is grater than 10\")\n",
    "except CustomException as ce:\n",
    "    print(\"The error raised: \" + ce.message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 53\n",
    "> ***Assuming that we have some email addresses in the \"username@companyname.com\" format, please write program to print the user name of a given email address. Both user names and company names are composed of letters only.***\n",
    "\n",
    "> ***Example:\n",
    "If the following email address is given as input to the \n",
    "program:***\n",
    "```\n",
    "john@google.com\n",
    "```\n",
    "> ***Then, the output of the program should be:***\n",
    "```\n",
    "john\n",
    "```\n",
    "> ***In case of input data being supplied to the question, it should be assumed to be a console input.***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "john@google.com\n",
      "name: john\n"
     ]
    }
   ],
   "source": [
    "email_adress = [ x for x in input().split('@')]\n",
    "print('name:',email_adress[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['john']\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "email = \"john@google.com\"\n",
    "pattern = \"(\\w+)@\\w+.com\"\n",
    "ans = re.findall(pattern,email)\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 54\n",
    "\n",
    "> ***Assuming that we have some email addresses in the \"username@companyname.com\" format, please write program to print the company name of a given email address. Both user names and company names are composed of letters only.***\n",
    "\n",
    "> ***Example:\n",
    "If the following email address is given as input to the program:***\n",
    "```\n",
    "john@google.com\n",
    "```\n",
    "> ***Then, the output of the program should be:***\n",
    "```\n",
    "google\n",
    "```\n",
    "> ***In case of input data being supplied to the question, it should be assumed to be a console input.***\n",
    "\n",
    "### Hints \n",
    "> ***Use \\w to match letters.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['google']\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "email = \"john@google.com\"\n",
    "pattern = \"\\w+@(\\w+).com\"\n",
    "ans = re.findall(pattern,email)\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 55\n",
    ">***Write a program which accepts a sequence of words separated by whitespace as input to print the words composed of digits only.***\n",
    "\n",
    ">***Example:\n",
    "If the following words is given as input to the program:***\n",
    "```\n",
    "2 cats and 3 dogs.\n",
    "```\n",
    ">***Then, the output of the program should be:***\n",
    "```\n",
    "['2', '3']\n",
    "```\n",
    ">***In case of input data being supplied to the question, it should be assumed to be a console input.***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 cats and 3 dogs.\n",
      "['2', '3']\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "email = input()\n",
    "pattern = \"\\d+\"\n",
    "ans = re.findall(pattern,email)\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 cats and 3 dogs.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[2, 3]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[int(s) for s in input().split() if s.isdigit()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 56\n",
    "> ***Print a unicode string \"hello world\".***\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world!\n"
     ]
    }
   ],
   "source": [
    "unicodeString = u\"hello world!\"\n",
    "print(unicodeString)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 57\n",
    "> ***Write a program to read an ASCII string and to convert it to a unicode string encoded by utf-8.***\n",
    "\n",
    "\n",
    "### Hints \n",
    "> ***Use unicode()/encode() function to convert.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adfaf\n",
      "b'adfaf'\n"
     ]
    }
   ],
   "source": [
    "s = input()\n",
    "u = s.encode('utf-8')\n",
    "print(u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 58\n",
    "> ***Write a special comment to indicate a Python source code file is in unicode.***\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 59\n",
    ">***Write a program to compute 1/2+2/3+3/4+...+n/n+1 with a given n input by console (n>0).***\n",
    "\n",
    ">***Example:\n",
    "If the following n is given as input to the program:***\n",
    "```\n",
    "5\n",
    "```\n",
    ">***Then, the output of the program should be:***\n",
    "```\n",
    "3.55\n",
    "```\n",
    ">***In case of input data being supplied to the question, it should be assumed to be a console input.***\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "6.17\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "sum = 0\n",
    "for i in range(1, n+1):\n",
    "    sum+= i/(i+1)\n",
    "print(round(sum, 2))  # rounded to 2 decimal point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 60\n",
    "\n",
    ">***Write a program to compute:***\n",
    "```\n",
    "f(n)=f(n-1)+100 when n>0\n",
    "and f(0)=1\n",
    "```\n",
    ">***with a given n input by console (n>0).***\n",
    "\n",
    ">***Example:\n",
    "If the following n is given as input to the program:***\n",
    "```\n",
    "5\n",
    "```\n",
    ">***Then, the output of the program should be:***\n",
    "```\n",
    "500\n",
    "```\n",
    ">***In case of input data being supplied to the question, it should be assumed to be a console input.***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "400\n"
     ]
    }
   ],
   "source": [
    "def f(n):\n",
    "    if n==0:\n",
    "        return 0\n",
    "    else:\n",
    "        return f(n-1)+100\n",
    "\n",
    "n=int(input())\n",
    "print(f(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci_recursive(n):\n",
    "    print(\"Calculating F\", \"(\", n, \")\", sep=\"\", end=\", \")\n",
    "\n",
    "    # Base case\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    elif n == 1:\n",
    "        return 1\n",
    "\n",
    "    # Recursive case\n",
    "    else:\n",
    "        return fibonacci_recursive(n-1) + fibonacci_recursive(n-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating F(5), Calculating F(4), Calculating F(3), Calculating F(2), Calculating F(1), Calculating F(0), Calculating F(1), Calculating F(2), Calculating F(1), Calculating F(0), Calculating F(3), Calculating F(2), Calculating F(1), Calculating F(0), Calculating F(1), "
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci_recursive(5)"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}