Ineuron_Python_Advanced_Programming16.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming16.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O6imFcWKwc0v"
      },
      "source": [
        "#Ineuron Python Advanced Programming 16"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hUTOghq8w4Id"
      },
      "source": [
        ">Q.1. Rondo Form is a type of musical structure, in which there is a recurring theme/refrain, notated as A. Here are the rules for valid rondo forms:\n",
        "\n",
        "   - Rondo forms always start and end with an A section.\n",
        "   - In between the A sections, there should be contrasting sections notated as B, then C, then D, etc... No letter should be skipped.\n",
        "   - There shouldn't be any repeats in the sequence (such as ABBACCA).\n",
        "\n",
        "Create a function which validates whether a given string is a valid Rondo 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",
      "metadata": {
        "id": "Rp3_9VyMtSqz"
      },
      "source": [
        "def valid_rondo(s):\n",
        "    letter = ord(\"A\")\n",
        "    next_letter = ord(\"B\")\n",
        "    l= len(s)\n",
        "    if l<2:\n",
        "        return False\n",
        "    elif s[0] and s[l-1] != \"A\":\n",
        "        return False\n",
        "    else:\n",
        "        for i in range(0,l-1,2):\n",
        "\n",
        "            if s[i]!= \"A\":\n",
        "                return False\n",
        "            else:\n",
        "                for i in range(1,l-1,2):\n",
        "\n",
        "                    if ord(s[i]) != next_letter:\n",
        "                        return False\n",
        "                    else:\n",
        "                        next_letter += 1\n",
        "                return True"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "USU_CkWbw_qJ",
        "outputId": "b85105b4-e5f0-4788-8a4f-14e48222c65a"
      },
      "source": [
        "valid_rondo(\"ABACADAEAFAGAHAIAJA\")\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iej2XNY_xByE",
        "outputId": "371b44f7-1969-45d9-bdef-656e2c19dd0a"
      },
      "source": [
        "valid_rondo(\"ACAC\")\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yujD653qxDI5",
        "outputId": "21c05073-f594-4840-ecc6-90ad829e926c"
      },
      "source": [
        "valid_rondo(\"ABBACCA\")\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SLxlKqoRxFV-",
        "outputId": "e331a792-0176-4bcb-8f74-b1b8bc461079"
      },
      "source": [
        "valid_rondo(\"ACAC\")\n"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R2dvm-QjxG5m",
        "outputId": "05fad528-df7a-45ed-9d5f-a0e63bebe899"
      },
      "source": [
        "valid_rondo(\"A\")\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p_AnNLECxMJV"
      },
      "source": [
        ">Q. 2. Create a function that returns the whole of the first sentence which 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",
      "metadata": {
        "id": "vPKv_AGAxIBw"
      },
      "source": [
        "def sentence_searcher(txt,s):\n",
        "    t = txt.split(\".\")\n",
        "    s=s.lower()\n",
        "    for i in t:\n",
        "        x=i.lower()\n",
        "        if s in x:\n",
        "\n",
        "            return i\n",
        "        return \"\" \n",
        "    \n",
        "txt = \"I have a cat. I have a mat. Things are going swell.\""
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "LYOurw2txQhp",
        "outputId": "60797ea9-63c7-4bb3-d698-380a9229f67a"
      },
      "source": [
        "sentence_searcher(txt, \"have\")\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'I have a cat'"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "TQ9xv9dhxXyO",
        "outputId": "fde0e022-3790-48ee-e184-94fea9728089"
      },
      "source": [
        "sentence_searcher(txt, \"MAT\")\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "''"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "9hV9pqn_xlX8",
        "outputId": "7a352bfc-2a80-4fb5-9453-839ea4b4f2f8"
      },
      "source": [
        "sentence_searcher(txt, \"things\")\n"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "''"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "UA-5cc8oxoOG",
        "outputId": "a130f769-ccab-4130-a478-6c2a6ae6c70d"
      },
      "source": [
        "sentence_searcher(txt, \"flat\")\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "''"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bpuYEXP-x9mn"
      },
      "source": [
        ">Q. 3. Given a number, find the \"round \"of each digit of the number. An integer is called \"round\" if all its digits except the leftmost (most significant) are equal to zero.\n",
        "\n",
        "    - Round numbers: 4000, 1, 9, 800, 90\n",
        "    - Not round numbers: 110, 707, 222, 1001\n",
        "\n",
        "Create a function that takes a number and returns the \"round\" of each digit (except if the digit is zero) as a string. Check out the following examples for 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\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tv-PBExdx3qu"
      },
      "source": [
        "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"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "JyatyW75x_9j",
        "outputId": "d546f80f-cdc5-4442-c17f-f1de6876b141"
      },
      "source": [
        "sum_round(101)\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'1 100 '"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "3rdbch6ryBgg",
        "outputId": "26faf6e8-0751-4a8d-a615-2e8aa38405b0"
      },
      "source": [
        "sum_round(1234)\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'4 30 200 1000 '"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "E9_FJKuLyCbN",
        "outputId": "45fe27e6-edbd-4328-b9da-4738f37b12d5"
      },
      "source": [
        "sum_round(54210)\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'10 200 4000 50000 '"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XbS-O6QMyHz-"
      },
      "source": [
        ">Q.4. Your task, is to create N x N multiplication table, of size n provided in\n",
        "parameter.\n",
        "For example, when n is 5, the multiplication table is:\n",
        "- 1, 2, 3, 4, 5\n",
        "- 2, 4, 6, 8, 10\n",
        "- 3, 6, 9, 12, 15\n",
        "- 4, 8, 12, 16, 20\n",
        "- 5, 10, 15, 20, 25\n",
        "This example will result in:\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",
        "Examples\n",
        "multiplication_table(1) ➞ [[1]]\n",
        "multiplication_table(3) ➞ [[1, 2, 3], [2, 4, 6], [3, 6, 9]]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JgPPtRpVyDWe"
      },
      "source": [
        "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"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LEKLK5g2yFvG",
        "outputId": "a26c7132-9543-4365-f4b6-9a12c60690ef"
      },
      "source": [
        "multiplication_table(1)\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1]]"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bHtV_AZuyOnp",
        "outputId": "e8b08061-fcee-4d02-86fd-f7b2659e1d2b"
      },
      "source": [
        "multiplication_table(3)\n"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1, 2, 3], [2, 4, 6], [3, 6, 9]]"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hBOL5usnyPw1",
        "outputId": "ec55b9c7-6f37-4890-c56e-e9c49a608a95"
      },
      "source": [
        "multiplication_table(5)\n"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1, 2, 3, 4, 5],\n",
              " [2, 4, 6, 8, 10],\n",
              " [3, 6, 9, 12, 15],\n",
              " [4, 8, 12, 16, 20],\n",
              " [5, 10, 15, 20, 25]]"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CUD5EKDMydT2"
      },
      "source": [
        ">Q. 5. Create a function that returns True if two lines rhyme and False otherwise. For the purposes of this exercise, two lines rhyme if the last word from each 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",
        "does_rhyme(\"You are off to the races\", \"a splendid day.\") ➞ False\n",
        "\n",
        "does_rhyme(\"and frequently do?\", \"you gotta move.\") ➞ False"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jXa2NGJwyQ4h"
      },
      "source": [
        "\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"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9IMa0qA9ygfP",
        "outputId": "1e58793d-401c-496e-ac72-d49505e95aad",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "does_rhyme(\"Sam I am!\", \"Green eggs and ham.\")\n"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yBB_NIikyhy0",
        "outputId": "8b6f7d0d-4bed-4f22-f00a-cc10fe22a550",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "does_rhyme(\"and frequently do?\", \"you gotta move.\")\n"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hJDx6kPZyjDA",
        "outputId": "182bde3f-210e-4e1a-f6f9-6c223ae822dd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "does_rhyme(\"Sam I am!\", \"Green eggs and HAM.\")\n"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XY0HiUNPyk8O",
        "outputId": "2d04b829-1295-4803-b02d-69c2e69a07f1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "does_rhyme(\"You are off to the races\", \"a splendid day.\")\n"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    }
  ]
}