Python Basic Programming Assignment-17.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basic Programming Assignment-17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging as lg\n",
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "lg.basicConfig(filename = \"logfile.log\", level = lg.INFO, format = '%(asctime)s %(name)s %(message)s')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question1. Create a function that takes three arguments a, b, c and returns the sum of the numbers that are evenly divided by c from the range a, b inclusive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evenly_divisible(a, b, c):\n",
    "    try:\n",
    "        divisible_list = []\n",
    "        for i in range(a, b+1):\n",
    "            if i % c == 0:\n",
    "                divisible_list.append(i)\n",
    "                \n",
    "        return_sum = sum(divisible_list)\n",
    "        \n",
    "        return return_sum\n",
    "        \n",
    "    except Exception as e:\n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evenly_divisible(1, 10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evenly_divisible(1, 10, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evenly_divisible(1, 10, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question2. Create a function that returns True if a given inequality expression is correct and False otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def correct_signs(inequality_expr):\n",
    "    \"\"\"\n",
    "    This function takes as input an inequality statement in the form of a string and\n",
    "    validates if it is True or Not, and returns a results accordingly.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        lg.info(\"Input by user: {}\".format(inequality_expr))\n",
    "        \n",
    "        pattern1 = re.compile(r\"^( *\\d+ *[<>] *)+ *\\d+ *$\")\n",
    "\n",
    "        if bool(pattern1.match(inequality_expr)) :\n",
    "            pattern2 = re.compile(r\"\\d+\")\n",
    "            pattern3 = re.compile(r\"[<>]\")\n",
    "\n",
    "            numbers_list = pattern2.findall(inequality_expr)\n",
    "            operators_list = pattern3.findall(inequality_expr)\n",
    "\n",
    "            for i in range(len(numbers_list) - 1):\n",
    "                if operators_list[i] == '>':\n",
    "\n",
    "                    if int(numbers_list[i]) > int(numbers_list[i+1]):\n",
    "                        continue\n",
    "                    else:\n",
    "                        return False\n",
    "\n",
    "                else:\n",
    "                    if int(numbers_list[i]) < int(numbers_list[i+1]):\n",
    "                        continue\n",
    "                    else:\n",
    "                        return False\n",
    "\n",
    "            else:\n",
    "                return True\n",
    "\n",
    "        else:\n",
    "            print(\"Pattern not in expected format\")\n",
    "        \n",
    "    except Exception as e:\n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "correct_signs(\"3 < 7 < 11\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "correct_signs(\"13 > 44 > 33 > 1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "correct_signs(\"1 < 2 < 6 < 9 > 3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "correct_signs(\"100 > 99\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pattern not in expected format\n"
     ]
    }
   ],
   "source": [
    "correct_signs(\"99 >= 45\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "correct_signs(\"  78 >   90 > 45\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "correct_signs(\"   67 > 65    < 100   \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question3. Create a function that replaces all the vowels in a string with a specified character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "pattern = re.compile(r\"[aioueAIOUE]\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'th# ##rdv#rk'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.sub(r\"[aioueAIOUE]\", \"#\", \"the aardvark\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace_vowels(string_input, repl_char):\n",
    "    try:\n",
    "        lg.info(\"Input by user - string input: {}, replace character: {}\".format(string_input, repl_char))\n",
    "        \n",
    "        return_string = re.sub(r\"[aioueAIOUE]\", repl_char, string_input)\n",
    "        \n",
    "        return return_string\n",
    "    \n",
    "    except Exception as e:\n",
    "        \n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'th# ##rdv#rk'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "replace_vowels(\"the aardvark\", \"#\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'m?nn?? m??s?'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "replace_vowels(\"minnie mouse\", \"?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sh*k*sp**r*'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "replace_vowels(\"shakespeare\", \"*\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 4. Write a function that calculates the factorial of a number recursively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(num):\n",
    "    try:\n",
    "        if num == 0 or num == 1:\n",
    "            return 1\n",
    "        \n",
    "        return num * factorial(num-1)\n",
    "    \n",
    "    except Exception as e:\n",
    "        \n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 5. Create a function that computes the hamming distance between two strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hamming_distance(str1, str2):\n",
    "    try:\n",
    "        lg.info(\"Input by user - string input 1: {}, string input 2: {}\".format(str1, str2))\n",
    "        \n",
    "        if len(str1) == len(str2):\n",
    "            \n",
    "            hamming_dist_val = 0\n",
    "            \n",
    "            for i in range(len(str1)):\n",
    "                if not str1[i] == str2[i]:\n",
    "                    hamming_dist_val += 1\n",
    "            \n",
    "            return hamming_dist_val\n",
    "               \n",
    "        else:\n",
    "            print(\"Lengths of the 2 inputs not same\")\n",
    "            lg.error(\"Lengths of 2 strings not same\")\n",
    "    \n",
    "    except Exception as e:\n",
    "        \n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hamming_distance(\"abcde\", \"bcdef\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hamming_distance(\"abcde\", \"abcde\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hamming_distance(\"strong\", \"strung\")"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}