programming_assignment_advance_16.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a696b06a",
   "metadata": {},
   "source": [
    "#Question : 01\n",
    "\n",
    "Rondo Form is a type of musical structure, in which there is a recurring\n",
    "theme/refrain, notated as A. Here are the rules for valid rondo forms:\n",
    "- Rondo forms always start and end with an A section.\n",
    "- In between the A sections, there should be contrasting sections notated as\n",
    "B, then C, then D, etc... No letter should be skipped.\n",
    "- There shouldn&#39;t be any repeats in the sequence (such as ABBACCA).\n",
    "Create a function which validates whether a given string is a valid Rondo\n",
    "Form.\n",
    "\n",
    "Examples\n",
    "\n",
    "valid_rondo(\"ABACADAEAFAGAHAIAJA\") ➞ True\n",
    "\n",
    "valid_rondo(\"ABA\") ➞ True\n",
    "\n",
    "valid_rondo(\"ABBACCA\") ➞ False\n",
    "\n",
    "valid_rondo(\"ACAC\") ➞ False\n",
    "\n",
    "valid_rondo(\"A\") ➞ False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "00e98dd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#code\n",
    "def valid_rondo(value):\n",
    "    x=ord(\"A\")\n",
    "    x=x+1\n",
    "    if value[0]!=\"A\" or value[-1]!=\"A\" or len(value)==1:\n",
    "        return False\n",
    "    else:\n",
    "        for i in range(0,len(value),2):\n",
    "            if i%2!=0:\n",
    "                if ord(value[i])==x:\n",
    "                    x+=1\n",
    "                else:\n",
    "                    return False\n",
    "    return True\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0ed8157e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "valid_rondo(\"ABA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "46b6e894",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "valid_rondo(\"ABACADAEAFAGAHAIAJA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5d635a05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "valid_rondo(\"ACAC\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5e2bd095",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "valid_rondo(\"A\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b416050",
   "metadata": {},
   "source": [
    "#Question : 02\n",
    "\n",
    "Create a function that returns the whole of the first sentence which\n",
    "contains a specific word. Include the full stop at the end of the sentence.\n",
    "\n",
    "Examples\n",
    "\n",
    "txt = \"I have a cat. I have a mat. Things are going swell.\"\n",
    "\n",
    "sentence_searcher(txt, \"have\") ➞ \"I have a cat.\"\n",
    "\n",
    "sentence_searcher(txt, \"MAT\") ➞ \"I have a mat.\"\n",
    "\n",
    "sentence_searcher(txt, \"things\") ➞ \"Things are going swell.\"\n",
    "\n",
    "sentence_searcher(txt, \"flat\") ➞ \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "1d55742f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sentence_searcher(txt,value):\n",
    "    sentence = txt.split(\".\")\n",
    "    for j in sentence:\n",
    "        if value.lower() in j:\n",
    "            sentence.remove(j)\n",
    "            print(j,\".\")\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "20a8107c",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = \"I have a cat. I have a mat. things are going swell.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "89352903",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I have a cat .\n"
     ]
    }
   ],
   "source": [
    "sentence_searcher(txt, \"have\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "6f38c1f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " I have a mat .\n"
     ]
    }
   ],
   "source": [
    "sentence_searcher(txt, \"mat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "9adeec7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " things are going swell .\n"
     ]
    }
   ],
   "source": [
    "sentence_searcher(txt, \"things\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "ecffcd6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence_searcher(txt, \"flat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cac1e16a",
   "metadata": {},
   "source": [
    "#Question : 03\n",
    "\n",
    "Given a number, find the \"round \"of each digit of the number. An integer is\n",
    "called \"round\" if all its digits except the leftmost (most significant) are equal to\n",
    "zero.\n",
    "\n",
    "- Round numbers: 4000, 1, 9, 800, 90\n",
    "\n",
    "- Not round numbers: 110, 707, 222, 1001\n",
    "\n",
    "Create a function that takes a number and returns the \"round\" of each digit\n",
    "(except if the digit is zero) as a string. Check out the following examples for\n",
    "more clarification.\n",
    "\n",
    "Examples\n",
    "\n",
    "sum_round(101) ➞ \"1 100\"\n",
    "\n",
    "sum_round(1234) ➞ \"4 30 200 1000\"\n",
    "\n",
    "sum_round(54210) ➞ \"10 200 4000 50000\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "b1f1f4bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#code\n",
    "def sum_round(n):\n",
    "    n=str(n)\n",
    "    n=n[::-1]\n",
    "    z = \"\"\n",
    "    for i in range(len(n)):\n",
    "        x = int(n[i])*(10**i) \n",
    "        if x != 0:\n",
    "            z += str(x)\n",
    "            z += \" \"\n",
    "    return z \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "86518fd9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 100 '"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_round(101)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "dcebbfb4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4 30 200 1000 '"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_round(1234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "19613f29",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10 200 4000 50000 '"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_round(54210)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69392e8a",
   "metadata": {},
   "source": [
    "#Question : 04\n",
    "\n",
    "Your task, is to create N x N multiplication table, of size n provided in\n",
    "parameter.\n",
    "\n",
    "For example, when n is 5, the multiplication table is:\n",
    "\n",
    "- 1, 2, 3, 4, 5\n",
    "\n",
    "- 2, 4, 6, 8, 10\n",
    "\n",
    "- 3, 6, 9, 12, 15\n",
    "\n",
    "- 4, 8, 12, 16, 20\n",
    "\n",
    "- 5, 10, 15, 20, 25\n",
    "This example will result in:\n",
    "\n",
    "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4, 8, 12, 16, 20], [5, 10, 15, 20,\n",
    "25]]\n",
    "\n",
    "Examples\n",
    "\n",
    "multiplication_table(1) ➞ [[1]]\n",
    "\n",
    "multiplication_table(3) ➞ [[1, 2, 3], [2, 4, 6], [3, 6, 9]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "d9625a76",
   "metadata": {},
   "outputs": [],
   "source": [
    "#code\n",
    "def multiplication_table(n):   \n",
    "    t = 1\n",
    "    tab = []\n",
    "    tmp = []\n",
    "    while t <= n:\n",
    "        tmp = []\n",
    "        for i in range(1,n+1):\n",
    "            tmp.append(i*t)\n",
    "        tab.append(tmp)\n",
    "        t = t + 1\n",
    "    return tab    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "a033f7c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1]]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiplication_table(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "7a250b0f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [2, 4, 6], [3, 6, 9]]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiplication_table(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10f6b9a2",
   "metadata": {},
   "source": [
    "#Question : 05\n",
    "\n",
    "Create a function that returns True if two lines rhyme and False otherwise.\n",
    "For the purposes of this exercise, two lines rhyme if the last word from each\n",
    "sentence contains the same vowels.\n",
    "\n",
    "Examples\n",
    "\n",
    "does_rhyme(\"Sam I am!\", \"Green eggs and ham.\") ➞ True\n",
    "\n",
    "does_rhyme(\"Sam I am!\", \"Green eggs and HAM.\") ➞ True\n",
    "\n",
    "# Capitalization and punctuation should not matter.\n",
    "\n",
    "\n",
    "\n",
    "does_rhyme(\"You are off to the races\", \"a splendid day.\") ➞ False\n",
    "\n",
    "does_rhyme(\"and frequently do?\", \"you gotta move.\") ➞ False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "6b18a05a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#code\n",
    "def last(s):\n",
    "    s=s.split(\" \")[-1]\n",
    "    n1=\"\"\n",
    "    for i in s:\n",
    "        if (i.isalpha()) == True:\n",
    "            n1+=i\n",
    "    return n1\n",
    "def does_rhyme(s1,s2):\n",
    "    s1=last(s1)\n",
    "    s2=last(s2)\n",
    "    for i in range(len(s1),0,-1):\n",
    "        if s1 in s2:\n",
    "            return True\n",
    "        else:\n",
    "            return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "a5d6cc53",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "does_rhyme(\"Sam I am!\", \"Green eggs and ham.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "950a7f54",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "does_rhyme(\"and frequently do?\", \"you gotta move.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "999c9bed",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}