22_python_assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "931f2bf3-7183-4fb3-8f09-e7ec63f6929b",
   "metadata": {},
   "source": [
    "python programming assignment - 22"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b754c41-4b1f-4d38-b8f9-e126d1bd24b4",
   "metadata": {},
   "source": [
    "1.Create a function that 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",
    "\n",
    "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. Examples:\n",
    "list_operation(1, 10, 3) ➞ [3, 6, 9]\n",
    "list_operation(7, 9, 2) ➞ [8]\n",
    "list_operation(15, 20, 7) ➞ []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dff0e465-cf93-4384-b75c-c1f2c5a095a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output: ➞ [3, 6, 9]\n",
      "Output: ➞ [8]\n",
      "Output: ➞ []\n"
     ]
    }
   ],
   "source": [
    "def list_operation(start,end,divisor):\n",
    "    out_list = []\n",
    "    for ele in range(start,end+1):\n",
    "        if ele%divisor == 0:\n",
    "            out_list.append(ele)\n",
    "    print(f'Output: ➞ {out_list}')\n",
    "\n",
    "list_operation(1, 10, 3)\n",
    "list_operation(7, 9, 2)\n",
    "list_operation(15, 20, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7825aef3-355c-4ba8-b9b1-7919cb13035f",
   "metadata": {},
   "source": [
    "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.\n",
    "Examples:\n",
    "simon_says([1, 2], [5, 1]) ➞ True\n",
    "simon_says([1, 2], [5, 5]) ➞ False\n",
    "simon_says([1, 2, 3, 4, 5], [0, 1, 2, 3, 4]) ➞ True\n",
    "simon_says([1, 2, 3, 4, 5], [5, 5, 1, 2, 3]) ➞ False\n",
    "Notes:\n",
    "1. Both input lists will be of the same length, and will have a minimum length of 2.\n",
    "2. The values of the 0-indexed element in the second list and the n-1th indexed element in the first list do not matter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4cf25e09-1e7b-4340-81ce-fd41d758e41e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([1, 2], [5, 1]) ➞ True\n",
      "([1, 2], [5, 5]) ➞ False\n",
      "([1, 2, 3, 4, 5], [0, 1, 2, 3, 4]) ➞ True\n",
      "([1, 2, 3, 4, 5], [5, 5, 1, 2, 3]) ➞ False\n"
     ]
    }
   ],
   "source": [
    "def simon_says(in_list_1,in_list_2):\n",
    "    if len(in_list_1) == len(in_list_1) and len(in_list_1) >=2 and len(in_list_1) >=2:\n",
    "        if(in_list_1[:-1] == in_list_2[1:]):\n",
    "            print(f'{in_list_1,in_list_2} ➞ {True}')\n",
    "        else:\n",
    "            print(f'{in_list_1,in_list_2} ➞ {False}')\n",
    "            \n",
    "simon_says([1, 2], [5, 1])\n",
    "simon_says([1, 2], [5, 5])\n",
    "simon_says([1, 2, 3, 4, 5], [0, 1, 2, 3, 4])\n",
    "simon_says([1, 2, 3, 4, 5], [5, 5, 1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7e88141-fc27-42d8-ad2c-6adab2cb9bbb",
   "metadata": {},
   "source": [
    "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 a alphabetical order ? Create a function that takes in a list of names and returns the name of the secret society ?\n",
    "Examples:\n",
    "society_name([\"Adam\", \"Sarah\", \"Malcolm\"]) ➞ \"AMS\"\n",
    "society_name([\"Harry\", \"Newt\", \"Luna\", \"Cho\"]) ➞ \"CHLN\"\n",
    "society_name([\"Phoebe\", \"Chandler\", \"Rachel\", \"Ross\", \"Monica\", \"Joey\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1e7f1473-3c30-431f-94ba-e76866535d4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Adam', 'Sarah', 'Malcolm'] ➞ AMS\n",
      "['Harry', 'Newt', 'Luna', 'Cho'] ➞ CHLN\n",
      "['Phoebe', 'Chandler', 'Rachel', 'Ross', 'Monica', 'Joey'] ➞ CJMPRR\n"
     ]
    }
   ],
   "source": [
    "def society_name(in_list):\n",
    "    out_string = []\n",
    "    for ele in in_list:\n",
    "        out_string.append(ele[0])\n",
    "    output = ''.join(sorted(out_string))\n",
    "    print(f'{in_list} ➞ {output}')\n",
    "\n",
    "society_name([\"Adam\", \"Sarah\", \"Malcolm\"])\n",
    "society_name([\"Harry\", \"Newt\", \"Luna\", \"Cho\"])\n",
    "society_name([\"Phoebe\", \"Chandler\", \"Rachel\", \"Ross\", \"Monica\", \"Joey\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df93c935-a9b3-4b0c-a871-2aa452783622",
   "metadata": {},
   "source": [
    "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\".\n",
    "Examples:\n",
    "is_isogram(\"Algorism\") ➞ True\n",
    "is_isogram(\"PasSword\") ➞ False\n",
    "# Not case sensitive.\n",
    "is_isogram(\"Consecutive\") ➞ False\n",
    "\n",
    "Notes:\n",
    "Ignore letter case (should not be case sensitive).\n",
    "All test cases contain valid one word strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7fd6aec1-75eb-4442-b014-ad583af5060e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Algorism ➞ True\n",
      "PasSword ➞ False\n",
      "Consecutive ➞ False\n"
     ]
    }
   ],
   "source": [
    "def is_isogram(in_string):\n",
    "    lower_in_string = in_string.lower()\n",
    "    if len(lower_in_string) == len(set(lower_in_string)):\n",
    "        print(f'{in_string} ➞ {True}')\n",
    "    else:\n",
    "        print(f'{in_string} ➞ {False}')\n",
    "    \n",
    "is_isogram(\"Algorism\")\n",
    "is_isogram(\"PasSword\")\n",
    "is_isogram(\"Consecutive\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b672cc28-a3d3-4c3f-89db-9d13759f3b72",
   "metadata": {},
   "source": [
    "5.Create a function that takes a string and returns True or False, depending on whether the characters are in order or not ?\n",
    "Examples:\n",
    "is_in_order(\"abc\") ➞ True\n",
    "is_in_order(\"edabit\") ➞ False\n",
    "is_in_order(\"123\") ➞ True\n",
    "is_in_order(\"xyzz\") ➞ True\n",
    "Notes:\n",
    "You don't have to handle empty strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f39c6bf0-c75a-4293-8b5d-8e45ae31d900",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc ➞ True\n",
      "edabit ➞ False\n",
      "123 ➞ True\n",
      "xyzz ➞ True\n"
     ]
    }
   ],
   "source": [
    "def is_in_order(in_string):\n",
    "    in_string_sorted = ''.join(sorted(in_string))\n",
    "    if in_string == in_string_sorted:\n",
    "        print(f'{in_string} ➞ {True}')\n",
    "    else:\n",
    "       print(f'{in_string} ➞ {False}')\n",
    "\n",
    "is_in_order(\"abc\")\n",
    "is_in_order(\"edabit\")\n",
    "is_in_order(\"123\")\n",
    "is_in_order(\"xyzz\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}