Python Basic Programming Assignment-22.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basic Programming Assignment-22"
   ]
  },
  {
   "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 parameters where: x is the start of the range (inclusive). y is the end of the range (inclusive). n is the divisor to be checked against. Return an ordered list with numbers in the range that are divisible by the third parameter n. Return an empty list if there are no numbers that are divisible by n.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_operation(x, y, n):\n",
    "    \"\"\"\n",
    "    This function takes three parameters where: \n",
    "    x is the start of the range (inclusive). \n",
    "    y is the end of the range (inclusive). \n",
    "    n is the divisor to be checked against. \n",
    "    The function returns an ordered list with numbers \n",
    "    in the range that are divisible by the third parameter n. \n",
    "    Return an empty list if there are no numbers that are divisible by n.\n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        lg.info(\"Input by user, x: {}, y: {}, n: {}\".format(x, y, n))\n",
    "        \n",
    "        return_list = []\n",
    "    \n",
    "        for i in range(x, y+1):\n",
    "            if i % n == 0:\n",
    "                return_list.append(i)\n",
    "\n",
    "        return return_list\n",
    "        \n",
    "    except Exception as e:\n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 9]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_operation(1, 10, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_operation(7, 9, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_operation(15, 20, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 2. Create a function that takes in two lists and returns True if the second list follows the first list by one element, and False otherwise. In other words, determine if the second list is the first list shifted to the right by 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simon_says(list1, list2):\n",
    "    \"\"\"\n",
    "    This function takes in two lists and returns True if the second list follows the first list \n",
    "    by one element, and False otherwise. In other words, determine if the second list is the \n",
    "    first list shifted to the right by 1.\n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        lg.info(\"Input by user, list1: {}, list2: {}\".format(list1, list2))\n",
    "        \n",
    "        if len(list1) == len(list2):\n",
    "            if list1[:-1] == list2[1:]:\n",
    "                return True\n",
    "            else:\n",
    "                return False\n",
    "        else:\n",
    "            print(\"lengths of the 2 lists are different\")\n",
    "            return False\n",
    "        \n",
    "    except Exception as e:\n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simon_says([1, 2], [5, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simon_says([1, 2], [5, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simon_says([1, 2, 3, 4, 5], [0, 1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simon_says([1, 2, 3, 4, 5], [5, 5, 1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 3. A group of friends have decided to start a secret society. The name will be the first letter of each of their names, sorted in alphabetical order. Create a function that takes in a list of names and returns the name of the secret society."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def society_name(list_of_names):\n",
    "    \"\"\"\n",
    "    This function takes in a list of names and returns the name of the secret society,\n",
    "    where secret society name is concatenation of the first letter of each of the names, \n",
    "    sorted in alphabetical order.\n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        lg.info(\"Input by user, list of names: {}\".format(list_of_names))\n",
    "        \n",
    "        society_name = \"\"\n",
    "        \n",
    "        for name in list_of_names:\n",
    "            if not name[0].isupper():\n",
    "                print(\"At least one of the names given as input does not have the first char as a Capital letter\")\n",
    "                return\n",
    "            else:\n",
    "                society_name += name[0]\n",
    "        \n",
    "        #return society_name\n",
    "        return \"\".join(sorted(society_name))\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": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AMS'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "society_name([\"Adam\", \"Sarah\", \"Malcolm\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'CHLN'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "society_name([\"Harry\", \"Newt\", \"Luna\", \"Cho\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'CJMPRR'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "society_name([\"Phoebe\", \"Chandler\", \"Rachel\", \"Ross\", \"Monica\", \"Joey\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 4. An isogram is a word that has no duplicate letters. Create a function that takes a string and returns either True or False depending on whether or not it's an \"isogram\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_isogram(string_inp):\n",
    "    \"\"\"\n",
    "    This function takes a string and returns either True or False \n",
    "    depending on whether or not it's an \"isogram\n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        lg.info(\"Input by user, string input: {}\".format(string_inp))\n",
    "        \n",
    "        sorted_chars_lower = sorted(string_inp.lower())\n",
    "        \n",
    "        for i in range(len(sorted_chars_lower) - 1):\n",
    "            if sorted_chars_lower[i] == sorted_chars_lower[i+1]:\n",
    "                return False\n",
    "        else:\n",
    "            return True\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": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_isogram(\"Algorism\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_isogram(\"PasSword\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_isogram(\"Consecutive\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Question 5. Create a function that takes a string and returns True or False, depending on whether the characters are in order or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_in_order(string_input):\n",
    "    \"\"\"\n",
    "    This function takes a string and returns True or False, \n",
    "    depending on whether the characters are in order or not.\n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        lg.info(\"Input by user, string input: {}\".format(string_input))\n",
    "        \n",
    "        if string_input.isnumeric() or string_input.isalpha():\n",
    "            \n",
    "            for i in range(len(string_input) - 1):\n",
    "                if not ( ord(string_input[i+1]) == ord(string_input[i]) + 1 or ord(string_input[i+1]) == ord(string_input[i])):\n",
    "                    return False\n",
    "            else:\n",
    "                return True\n",
    "        \n",
    "        else:\n",
    "            print(\"string not numeric or alphabetic\")\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": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_in_order(\"abc\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_in_order(\"edabit\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_in_order(\"123\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_in_order(\"xyzz\")"
   ]
  }
 ],
 "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
}