Task_13 Regex and Parsing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c633061c",
   "metadata": {},
   "source": [
    "# Subdomain : Regex and Parsing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cca0e95",
   "metadata": {},
   "source": [
    "### Problem 1 : Detect Floating Point Number\n",
    "* **You are given a string N.**\n",
    "* **Your task is to verify that N is a floating point number.**\n",
    "* **In this task, a valid float number must satisfy all of the following requirements:**\n",
    "* **Number can start with +, - or . symbol.**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f49ea3ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4.000\n",
      "True\n",
      "-1.00\n",
      "True\n",
      "+4.54\n",
      "True\n",
      "SomeRandomStuff\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "for i in range(int(input())):\n",
    "    print(bool(re.search(r\"^[+-]?[0-9]*\\.[0-9]+$\", input())))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dbec679",
   "metadata": {},
   "source": [
    "## Problem 2 : Re.split()\n",
    "* **You are given a string s consisting only of digits 0-9, commas ,, and dots .**\n",
    "* **Your task is to complete the regex_pattern defined below, which will be used to re.split() all of the , and . symbols in s.**\n",
    "* **It’s guaranteed that every comma and every dot in s is preceeded and followed by a digit.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0f4d5867",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100,000,000.000\n",
      "100\n",
      "000\n",
      "000\n",
      "000\n"
     ]
    }
   ],
   "source": [
    "regex_pattern = r\"[.,]+\" # Do not delete 'r'.\n",
    "\n",
    "import re\n",
    "print(\"\\n\".join(re.split(regex_pattern, input())))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aed3d778",
   "metadata": {},
   "source": [
    "## Problem 3 : Group(), Groups() & Groupdict()\n",
    "* **You are given a string S.**\n",
    "* **Your task is to find the first occurrence of an alphanumeric character in S (read from left to right) that has consecutive repetitions.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c46c3ca8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "..12345678910111213141516171820212223\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "string = input()\n",
    "m = re.search(r'([a-zA-Z0-9])\\1',string)\n",
    "if m:\n",
    "    print(m.group(1))\n",
    "else:\n",
    "    print(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02086e3d",
   "metadata": {},
   "source": [
    "## Problem 4 : Re.findall() & Re.finditer()\n",
    "* **You are given a string S. It consists of alphanumeric characters, spaces and symbols(+,-).**\n",
    "* **Your task is to find all the substrings of S that contains 2 or more vowels.**\n",
    "* **Also, these substrings must lie in between 2 consonants and should contain vowels only.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "af63d9d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rabcdeefgyYhFjkIoomnpOeorteeeeet\n",
      "ee\n",
      "Ioo\n",
      "Oeo\n",
      "eeeee\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "string = input()\n",
    "m = re.escape(string) # for deleting characters,spaces & symbols\n",
    "vowels = ' aeiou'\n",
    "consonants = 'qwrtypsdfghjklzxcvbnm'\n",
    "match = re.findall(r'(?<=[' + consonants + '])([' + vowels + ']{2,})(?=[' + consonants + '])',m,flags=re.I)\n",
    "\n",
    "if len(match) > 0:\n",
    "    print(\"\\n\".join(match))\n",
    "else:\n",
    "    print(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ca2c81c",
   "metadata": {},
   "source": [
    "## Problem 5 : Re.start() & Re.end()\n",
    "* **You are given a string S.**\n",
    "* **Your task is to find the indices of the start and end of string k in S.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "11f0b885",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aaadaa\n",
      "aa\n",
      "(0, 1)\n",
      "(1, 2)\n",
      "(4, 5)\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "S = input()\n",
    "k = input()\n",
    "\n",
    "pattern = re.compile(k)\n",
    "match = pattern.search(S)\n",
    "if not match: print('(-1, -1)')\n",
    "while match:\n",
    "    print('({0}, {1})'.format(match.start(), match.end() - 1))\n",
    "    match = pattern.search(S, match.start() + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "690a46ce",
   "metadata": {},
   "source": [
    "## Problem 6 : Regex Substitution\n",
    "* **You are given a text of N lines. The text contains && and || symbols.**\n",
    "* **Your task is to modify those symbols to the following:**\n",
    "\n",
    "    **&& → and**\n",
    "    **|| → or**\n",
    "* **Both && and || should have a space \" \" on both sides.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "794a57b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "a = 1;\n",
      "a = 1;\n",
      "b = input();\n",
      "b = input();\n",
      "\n",
      "\n",
      "if a + b > 0 && a - b < 0:\n",
      "if a + b > 0 and a - b < 0:\n",
      "    start()\n",
      "    start()\n",
      "elif a*b > 10 || a/b < 1:\n",
      "elif a*b > 10 or a/b < 1:\n",
      "    stop()\n",
      "    stop()\n",
      "print set(list(a)) | set(list(b)) \n",
      "print set(list(a)) | set(list(b)) \n",
      "#Note do not change &&& or ||| or & or |\n",
      "#Note do not change &&& or ||| or & or |\n",
      "#Only change those '&&' which have space on both sides.\n",
      "#Only change those '&&' which have space on both sides.\n",
      "#Only change those '|| which have space on both sides.\n",
      "#Only change those '|| which have space on both sides.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "def change(match):\n",
    "    if match.group(1) == '&&':\n",
    "        return 'and'\n",
    "    else:\n",
    "        return 'or'\n",
    "\n",
    "for i in range(int(input())):\n",
    "    print(re.sub(r\"(?<= )(\\|\\||&&)(?= )\", change,input()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "037c2532",
   "metadata": {},
   "source": [
    "## Problem 7 : Validating Roman Numerals\n",
    "* **You are given a string, and you have to validate whether it's a valid Roman numeral. If it is valid, print True. Otherwise, print False. Try to create a regular expression for a valid Roman numeral.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8c00f340",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CDXXI\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "Thousand = 'M{0,3}'\n",
    "Hundred = '(C[MD]|D?C{0,3})'\n",
    "Ten = '(X[CL]|L?X{0,3})'\n",
    "Digit = '(I[VX]|V?I{0,3})'\n",
    "regex_pattern = r\"%s%s%s%s$\" % (Thousand, Hundred, Ten, Digit) # Do not delete 'r'.\n",
    "\n",
    "import re\n",
    "print(str(bool(re.match(regex_pattern, input()))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fe1a754",
   "metadata": {},
   "source": [
    "## Problem 8 : Validating phone numbers\n",
    "* **Let's dive into the interesting topic of regular expressions! You are given some input, and you are required to check whether they are valid mobile numbers.**\n",
    "* **A valid mobile number is a ten digit number starting with a 7 8 or 9.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "625c74f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "9587456281\n",
      "YES\n",
      "1252478965\n",
      "NO\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "N = int(input())\n",
    "\n",
    "for i in range(N):\n",
    "    if re.match(r'^[789]\\d{9}$',input()):\n",
    "        print(\"YES\")\n",
    "    else:\n",
    "        print(\"NO\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7c723c4",
   "metadata": {},
   "source": [
    "## Problem 9 : Validating and Parsing Email Addresses\n",
    "* **A valid email address meets the following criteria:**\n",
    "    * **It's composed of a username, domain name, and extension assembled in this format: username@domain.extension**\n",
    "    * **The username starts with an English alphabetical character, and any subsequent characters consist of one or more of the following: alphanumeric characters, -,., and _.**\n",
    "    * **The domain and extension contain only English alphabetical characters.**\n",
    "    * **The extension is 1, 2, or 3 characters in length.**\n",
    "* **Given n pairs of names and email addresses as input, print each name and email address pair having a valid email address on a new line.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8675fc3d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "DEXTER <dexter@hotmail.com>\n",
      "DEXTER <dexter@hotmail.com>\n",
      "VIRUS <virus!@variable.:p>\n"
     ]
    }
   ],
   "source": [
    "import email.utils\n",
    "import re\n",
    "\n",
    "n = int(input())\n",
    "for _ in range(n):\n",
    "    s = input()\n",
    "    parsed_email = email.utils.parseaddr(s)[1].strip()\n",
    "    match_result = bool(re.match(r\"(^[A-Za-z][A-Za-z0-9\\._-]+)@([A-Za-z]+)\\.([A-Za-z]{1,3})$\", parsed_email))\n",
    "    \n",
    "    if match_result:\n",
    "        print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfe34b90",
   "metadata": {},
   "source": [
    "## Problem 10 : Hex Color Code\n",
    "* **CSS colors are defined using a hexadecimal (HEX) notation for the combination of Red, Green, and Blue color values (RGB).**\n",
    "* **Specifications of HEX Color Code**\n",
    "    * **It must start with a '#' symbol.**\n",
    "    * **It can have 3 or 6 digits.**\n",
    "    * **Each digit is in the range of 0 to F. (1,2,3,4,5,6,7,8,9,0,A,B,C,D,E and F).**\n",
    "    * **A - F letters can be lower case.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "236ff314",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "#BED\n",
      "    color: #FfFdF8; background-color:#aef;\n",
      "#FfFdF8\n",
      "#aef\n",
      "    font-size: 123px;\n",
      "    background: -webkit-linear-gradient(top, #f9f9f9, #fff);\n",
      "#f9f9f9\n",
      "#fff\n",
      "}\n",
      "#Cab\n",
      "{\n",
      "    background-color: #ABC;\n",
      "#ABC\n",
      "    border: 2px dashed #fff;\n",
      "#fff\n",
      "}\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "n = int(input())\n",
    "for _ in range(n):\n",
    "    s = input()\n",
    "    match_result = re.findall(r\"(#[0-9A-Fa-f]{3}|#[0-9A-Fa-f]{6})(?:[;,.)]{1})\", s)\n",
    "    for i in match_result:\n",
    "        if i != \"\":\n",
    "            print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "263f3e6b",
   "metadata": {},
   "source": [
    "## Problem 11 : HTML Parser - Part 1\n",
    "* **You are given an HTML code snippet of N lines.**\n",
    "* **Your task is to print start tags, end tags and empty tags separately.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "39a50118",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "<html><head><title>HTML Parser - I</title></head>\n",
      "Start : html\n",
      "Start : head\n",
      "Start : title\n",
      "End   : title\n",
      "End   : head\n",
      "<body data-modal-target class='1'><h1>HackerRank</h1><br /></body></html>\n",
      "Start : body\n",
      "-> data-modal-target > None\n",
      "-> class > 1\n",
      "Start : h1\n",
      "End   : h1\n",
      "Empty : br\n",
      "End   : body\n",
      "End   : html\n"
     ]
    }
   ],
   "source": [
    "from html.parser import HTMLParser\n",
    "\n",
    "class MyParser(HTMLParser):\n",
    "    def handle_starttag(self, tag, attrs):\n",
    "        print(\"Start :\", tag)\n",
    "        for n, m in attrs:\n",
    "            print(\"->\", n, \">\", m)\n",
    "\n",
    "    def handle_startendtag(self, tag, attrs):\n",
    "        print(\"Empty :\", tag)\n",
    "        for n, m in attrs:\n",
    "            print(\"->\", n, \">\", m)\n",
    "\n",
    "    def handle_endtag(self, tag):\n",
    "        print(\"End   :\", tag)\n",
    "\n",
    "parser = MyParser()\n",
    "for i in range(int(input())):\n",
    "    parser.feed(input())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "070ee857",
   "metadata": {},
   "source": [
    "## Problem 12 : HTML Parser - Part 2\n",
    "* **You are given an HTML code snippet of N lines.**\n",
    "* **Your task is to print the single-line comments, multi-line comments and the data.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4ddafd90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "<!--[if IE 9]>IE9-specific content\n",
      "<![endif]-->\n",
      "<div> Welcome to HackerRank</div>\n",
      "<!--[if IE 9]>IE9-specific content<![endif]-->\n",
      ">>> Multi-line Comment\n",
      "[if IE 9]>IE9-specific content\n",
      "<![endif]\n",
      ">>> Data\n",
      " Welcome to HackerRank\n",
      ">>> Single-line Comment\n",
      "[if IE 9]>IE9-specific content<![endif]\n"
     ]
    }
   ],
   "source": [
    "from html.parser import HTMLParser\n",
    "\n",
    "class MyHTMLParser(HTMLParser):\n",
    "    def handle_comment(self, data):\n",
    "        if \"\\n\" in data:\n",
    "            print(\">>> Multi-line Comment\")\n",
    "            print(data)\n",
    "        else:\n",
    "            print(\">>> Single-line Comment\")\n",
    "            print(data)\n",
    "    def handle_data(self, data):\n",
    "        if data != \"\\n\":\n",
    "            print(\">>> Data\")\n",
    "            print(data)\n",
    "\n",
    "html = \"\"       \n",
    "for i in range(int(input())):\n",
    "    html += input().rstrip()\n",
    "    html += '\\n'\n",
    "    \n",
    "parser = MyHTMLParser()\n",
    "parser.feed(html)\n",
    "parser.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73323d4c",
   "metadata": {},
   "source": [
    "## Problem 13 : Detect HTML Tags, Attributes and Attribute Values\n",
    "* **You are given an HTML code snippet of N lines.**\n",
    "* **Your task is to detect and print all the HTML tags, attributes and attribute values.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "818429a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "<head>\n",
      "<title>HTML</title>\n",
      "</head>\n",
      "<object type=\"application/x-flash\" \n",
      "  data=\"your-file.swf\" \n",
      "  width=\"0\" height=\"0\">\n",
      "  <!-- <param name=\"movie\" value=\"your-file.swf\" /> -->\n",
      "  <param name=\"quality\" value=\"high\"/>\n",
      "</object>\n",
      "head\n",
      "title\n",
      "object\n",
      "-> type > application/x-flash\n",
      "-> data > your-file.swf\n",
      "-> width > 0\n",
      "-> height > 0\n",
      "param\n",
      "-> name > quality\n",
      "-> value > high\n"
     ]
    }
   ],
   "source": [
    "from html.parser import HTMLParser\n",
    "\n",
    "\n",
    "class html_parser(HTMLParser):\n",
    "    def handle_starttag(self, tag, attrs):\n",
    "        print(tag)\n",
    "        [print('-> {} > {}'.format(*attr)) for attr in attrs]\n",
    "        \n",
    "html = '\\n'.join([input() for _ in range(int(input()))])\n",
    "parser = html_parser()\n",
    "parser.feed(html)\n",
    "parser.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01479252",
   "metadata": {},
   "source": [
    "## Problem 14 : Validating UID\n",
    "* **ABCXYZ company has up to  employees.\n",
    "The company decides to create a unique identification number (UID) for each of its employees.\n",
    "The company has assigned you the task of validating all the randomly generated UIDs.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a84742cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "B1CD102354\n",
      "Invalid\n",
      "B1CDEF2354\n",
      "Valid\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "for _ in range(int(input())):\n",
    "    lst = []\n",
    "    s = input()\n",
    "    for i in [r\"[A-Z0-9]{10}\", r\"([A-Z].*){2,}\", r\"([0-9].*){3,}\"]:\n",
    "        lst.append(bool(re.search(i, s, flags=re.I)))\n",
    "    if all(lst) is True:\n",
    "        if bool(re.search(r\".*(.).*\\1.*\", s)) is True:\n",
    "            print(\"Invalid\")\n",
    "        else:\n",
    "            print(\"Valid\")\n",
    "    else:\n",
    "        print(\"Invalid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "215b259e",
   "metadata": {},
   "source": [
    "## Problem 15 : Validating Credit Card Numbers\n",
    "* **You and Fredrick are good friends. Yesterday, Fredrick received N credit cards from ABCD Bank. He wants to verify whether his credit card numbers are valid or not. You happen to be great at regex so he is asking for your help!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "5650e488",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "4123456789123456\n",
      "Valid\n",
      "5123-4567-8912-3456\n",
      "Valid\n",
      "61234-567-8912-3456\n",
      "Invalid\n",
      "4123356789123456\n",
      "Valid\n",
      "5133-3367-8912-3456\n",
      "Invalid\n",
      "5123 - 3567 - 8912 - 3456\n",
      "Invalid\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "n = int(input())\n",
    "for _ in range(n):\n",
    "    credit = input().strip()\n",
    "    credit_removed_hiphen = credit.replace(\"-\", \"\")\n",
    "    valid = True\n",
    "    length_16 = bool(re.match(r\"^[4-6]\\d{15}$\", credit))\n",
    "    length_19 = bool(re.match(r\"^[4-6]\\d{3}-\\d{4}-\\d{4}-\\d{4}$\", credit))\n",
    "    consecutive = bool(re.findall(r\"(?=(\\d)\\1\\1\\1)\", credit_removed_hiphen))\n",
    "    if length_16 == True or length_19 == True:\n",
    "        if consecutive == True:\n",
    "            valid = False\n",
    "    else:\n",
    "        valid = False\n",
    "    if valid:\n",
    "        print(\"Valid\")\n",
    "    else:\n",
    "        print(\"Invalid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb0b4387",
   "metadata": {},
   "source": [
    "# THE END!!"
   ]
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}