Strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings\n",
    "\n",
    "* Sequence of Characters\n",
    "* Used to store text data , the same type of data which reads from a file\n",
    "* Typically small set of characters\n",
    "* Character 'A' to 'Z' are stored as values from 65 to 90\n",
    "* Character 'a' to 'z' are stored as values from 97 to 122\n",
    "\n",
    "\n",
    "**Problems**\n",
    "\n",
    "1. [Reverse a String](#Reverse-a-String)\n",
    "7. [Check For Rotation](#Check-For-Rotation)\n",
    "7. [Check Palindrome](#Check-Palindrome)\n",
    "7. [Subsequences in a String](#Subsequences-in-a-String)\n",
    "7. [Recursuve Subsequence of a String](#Recursuve-Subsequence-of-a-String)\n",
    "7. [Check Anagram](#Check-Anagram)\n",
    "7. [Leftmost Repeating Character](#Leftmost-Repeating-Character)\n",
    "7. [Leftmost Non-Repeating Character](#Leftmost-Non-Repeating-Character)\n",
    "7. [Reverse Words in String](#Reverse-Words-in-String)\n",
    "7. [Length of String](#Length-of-String)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(65, 90, 97, 122)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('A'), ord('Z'), ord('a'), ord('z')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('A', 'Z', 'a', 'z')"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(65), chr(90),chr(97), chr(122)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"chandrashekhar\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('c', 'r', 'h')"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[0], s[-1], s[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c h a n d r a s h e k h a r \n",
      "\n",
      "0 1 2 3 4 5 6 7 8 9 10 11 12 13 "
     ]
    }
   ],
   "source": [
    "for i in s:\n",
    "    print(i, end=\" \")\n",
    "print('\\n')\n",
    "for i in range(len(s)):\n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c  h  a  n  d  r  a  s  h  e  k  h  a  r  \n",
      "\n",
      "-13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 "
     ]
    }
   ],
   "source": [
    "for i in s:\n",
    "    print(i, end=\"  \")\n",
    "print('\\n')\n",
    "for i in range(-len(s)+1,0,1):\n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"\"\"\n",
    "My self Chandrashekhar Robbi\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "My self Chandrashekhar Robbi\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "s  = \"Welcome to \\\"DSA\\\" \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Welcome to \"DSA\" '"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = r\"C:\\project\\name.py\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C:\\\\project\\\\name.py'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Format Strings in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Abc\"\n",
    "course = \"Python Course\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome Abc to the Python Course\n"
     ]
    }
   ],
   "source": [
    "# Using %\n",
    "print(\"Welcome %s to the %s\"%(name,course))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Abc to the Python Course\n"
     ]
    }
   ],
   "source": [
    "# Using format\n",
    "print(\"Welcome to {0} to the {1}\".format(name,course))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Abc to the Python Course\n"
     ]
    }
   ],
   "source": [
    "# Using f string (my fav one)\n",
    "print(f\"Welcome to {name} to the {course}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of 10 and 20 is 30\n"
     ]
    }
   ],
   "source": [
    "# f string\n",
    "a = 10\n",
    "b = 20\n",
    "print(f\"The sum of {a} and {b} is {a + b}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The upper case of Welcome to \"DSA\"  is WELCOME TO \"DSA\" \n"
     ]
    }
   ],
   "source": [
    "print(f\"The upper case of {s} is {s.upper()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = \"chandrashekharchandrashekhar\"\n",
    "s2 = \"shekhar\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7, 21)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.index(s2) ,s1.rindex(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.index(s2,8,len(s1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(28,\n",
       " 'CHANDRASHEKHARCHANDRASHEKHAR',\n",
       " False,\n",
       " 'chandrashekharchandrashekhar',\n",
       " True)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(s1),s1.upper(),s1.isupper(),s1.lower(),s1.islower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True, False)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.startswith(\"c\"), s1.endswith('r'),s1.startswith(\"Chandra\",1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1=\"Chandrashekhar Robbi\"\n",
    "s2 = \"Hello,Hi,Hey\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = s1.split()\n",
    "b = s2.split(',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['Chandrashekhar', 'Robbi'], ['Hello', 'Hi', 'Hey'])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a , b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Chandrashekhar Robbi', 'Hello,Hi,Hey')"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" \".join(a) , \",\".join(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "s3 = \"               Chandrashekhar                      \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'               Chandrashekhar                      '"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "s4 = \"------------Chanasdadljjs---------\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Chanasdadljjs', 'Chandrashekhar')"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s4.strip(\"-\") , s3.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Chanasdadljjs---------', 'Chandrashekhar                      ')"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s4.lstrip(\"-\") , s3.lstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('------------Chanasdadljjs', '               Chandrashekhar')"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s4.rstrip(\"-\") , s3.rstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Chandrashekhar Robbi'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as index but it doesn't raises error\n",
    "s1.find(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.find('she')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reverse a String\n",
    "\n",
    "Take input as a string and retrun the reverse of it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Chandrashekhar Robbi'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverseAString1(s):\n",
    "    return s[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ibboR rahkehsardnahC'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverseAString1(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverseAString2(s):\n",
    "    rev = \"\"\n",
    "    for i in s:\n",
    "        rev = i + rev\n",
    "    return rev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ibboR rahkehsardnahC'"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverseAString2(s1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Check For Rotation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = 'abcd'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "s2 = 'cdab'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def checkForRotation(s1,s2):\n",
    "    if len(s1) != len(s2):\n",
    "        return False\n",
    "    temp = ' '\n",
    "    temp = s1 + s1\n",
    "    return temp.find(s2) != -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkForRotation(s1,s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = 'abab' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "s2= 'abba'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkForRotation(s1,s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Check Palindrome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "def checkPalindrome1(s):\n",
    "    if len(s) == 1:\n",
    "        return 'yes'\n",
    "    else:\n",
    "        if s == s[::-1]:\n",
    "            return 'yes'\n",
    "        else:\n",
    "            return 'no'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = 'abaaba'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yes'"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkPalindrome1(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "s2 = 'acdb'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'no'"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkPalindrome1(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "def checkPalindrome2(s):\n",
    "    l = 0\n",
    "    h = len(s) -1\n",
    "    for _ in range(int(len(s)/2)):\n",
    "        if s[l] == s[h]:\n",
    "            l += 1\n",
    "            h -= 1\n",
    "        if l+1 == h:\n",
    "            return 'yes'\n",
    "        if l == h:\n",
    "            return 'yes'\n",
    "    return 'no'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yes'"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkPalindrome2(s1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Subsequences in a String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "def subsequenceString(s1,s2):\n",
    "    i,j = 0,0\n",
    "    while i <len(s1) and j<len(s2):\n",
    "        if s1[i] == s2[j]:\n",
    "            j += 1\n",
    "            i += 1\n",
    "        else:\n",
    "            i += 1\n",
    "    if j == len(s2):\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subsequenceString('chandrashekhar','crehar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subsequenceString('chandrashekhar','robbi')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Recursuve Subsequence of a String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recursiveSubsequenceString(s1,s2,i,j):\n",
    "    if j == 0:\n",
    "        return True\n",
    "    if i == 0:\n",
    "        return False\n",
    "    if s1[i-1] == s2[j-1]:\n",
    "        return recursiveSubsequenceString(s1,s2,i-1,j-1)\n",
    "    else:\n",
    "        return recursiveSubsequenceString(s1,s2,i-1,j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = 'chandrashekhar'\n",
    "s2 = 'chandra'\n",
    "s3 = 'robbi'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveSubsequenceString(s1,s2,len(s1),len(s2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveSubsequenceString(s1,s3,len(s1),len(s3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Check Anagram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "def checkAnagram1(s1,s2):\n",
    "    if len(s1) != len(s2):\n",
    "        return False\n",
    "    s1_s = sorted(s1)\n",
    "    s2_s = sorted(s2)\n",
    "    return (s1_s == s2_s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = 'abb'\n",
    "s2 = 'bab'\n",
    "s3 = 'abc'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkAnagram1(s1,s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkAnagram1(s1,s3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "def checkAnagram2(s1,s2):\n",
    "    if len(s1) != len(s2):\n",
    "        return False\n",
    "    count = [0] * 256\n",
    "    for i in range(len(s1)):\n",
    "        count[ord(s1[i])] += 1\n",
    "        count[ord(s2[i])] -= 1\n",
    "    for x in count:\n",
    "        if x != 0:\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkAnagram2(s1,s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkAnagram2(s1,s3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Leftmost Repeating Character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "def leftmostRepeating1(s):\n",
    "    for i in range(len(s)):\n",
    "        for j in range(i+1,len(s)):\n",
    "            if s[i] == s[j]:\n",
    "                return i\n",
    "    return -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "leftmostRepeating1('chandrhc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "leftmostRepeating1('chaj')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "def leftmostRepeating2(s):\n",
    "    count = [0] * 256\n",
    "    for i in range(len(s)):\n",
    "        count[ord(s[i])] += 1\n",
    "    for i in range(len(s)):\n",
    "        if count[ord(s[i])] > 1:\n",
    "            return i\n",
    "    return -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "leftmostRepeating2('chandra')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "leftmostRepeating2('chaj')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Leftmost Non-Repeating Character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "def leftmostNonRepeat1(s):\n",
    "    for i in range(len(s)):\n",
    "        no = False\n",
    "        for j in range(i+1,len(s)):\n",
    "            if s[i] == s[j]:\n",
    "                no = True\n",
    "        if no == False:\n",
    "            return i\n",
    "    return -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "leftmostNonRepeat1('abcba')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "def leftmostNonRepeat2(s):\n",
    "    count = [0] * 256\n",
    "    for i in range(len(s)):\n",
    "        count[ord(s[i])] += 1\n",
    "    for i in range(len(s)):\n",
    "        if count[ord(s[i])] == 1:\n",
    "            return i\n",
    "    return -1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "leftmostNonRepeat2('abcbacd')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reverse Words in String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverseWordString(s):\n",
    "    return ' '.join(s.split()[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Hello it's chandrashekhar\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"chandrashekhar it's Hello\""
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverseWordString(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reverse words in a string\n",
    "\n",
    "\n",
    "def reverse_word(s, start, end):\n",
    "    while start < end:\n",
    "        s[start], s[end] = s[end], s[start]\n",
    "        start = start + 1\n",
    "        end -= 1\n",
    "\n",
    "def reverseWords(s):\n",
    "\n",
    "    s = list(s)\n",
    "    start = 0\n",
    "    while True:\n",
    "\n",
    "        try:\n",
    "            end = s.index(' ', start)\n",
    "\n",
    "            reverse_word(s, start, end - 1)\n",
    "\n",
    "            start = end + 1\n",
    "\n",
    "        except ValueError:\n",
    "\n",
    "            reverse_word(s, start, len(s) - 1)\n",
    "            break\n",
    "\n",
    "    s.reverse()\n",
    "\n",
    "    s = \"\".join(s)\n",
    "\n",
    "    return s\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"bba zse\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'zse bba'"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverseWords(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Length of String\n",
    "\n",
    "You are given a string s. You need to find the length of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lengthString(str):\n",
    "    #code here\n",
    "    return len(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Anagram\n",
    "\n",
    "\n",
    "Given two strings a and b consisting of lowercase characters. The task is to check whether two given strings are an anagram of each other or not. An anagram of a string is another string that contains the same characters, only the order of characters can be different. For example, act and tac are an anagram of each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "def isAnagram(a,b):\n",
    "    #code here\n",
    "    if len(a) != len(b):\n",
    "        return False\n",
    "    x = sorted(a)\n",
    "    y = sorted(b)\n",
    "    if x == y:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "def isAnagram(self,a,b):\n",
    "    #code here\n",
    "    if len(a) != len(b):\n",
    "        return False\n",
    "    count1 = [0] * 256\n",
    "    count2 = [0] * 256\n",
    "    for i in range(len(a)):\n",
    "        count1[ord(a[i])] += 1\n",
    "    for j in range(len(b)):\n",
    "        count2[ord(b[j])] += 1\n",
    "    if count1 == count2:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vowels in String\n",
    "\n",
    "You are given a string s. You need to count the total vowels in the string. The string s contains lowercase letters only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "def countVowels(s):\n",
    "    count = 0\n",
    "    vowels = ['a','e','i','o','u']\n",
    "    for i in s:\n",
    "        if i in vowels:\n",
    "            count += 1\n",
    "    return count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Count Distinct Vowels in String\n",
    "\n",
    "You are given a string s. You need to count the total distinct vowels in the string. The string s contains lowercase letters only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "def countVowels(self,s):\n",
    "    #code here\n",
    "    vowels = ['a','e','i','o','u']\n",
    "    count = [0] * 256\n",
    "    c = 0\n",
    "    for i in range(len(s)):\n",
    "        count[ord(s[i])] += 1\n",
    "    for i in vowels:\n",
    "        if i in s:\n",
    "            if count[ord(i)] >= 1:\n",
    "                c += 1\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [],
   "source": [
    "def countVowels(s):\n",
    "    #code here\n",
    "    s1 = []\n",
    "    for i in s:\n",
    "        if (i == 'a' or i == 'e' or i == 'i' or i == 'o' or i == 'u'):\n",
    "            if i not in s1:\n",
    "                s1.append(i)\n",
    "    return len(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count Words in String\n",
      "7. [Count Words in String](#Count-Words-in-String)\n",
      "#### Count Words in String\n"
     ]
    }
   ],
   "source": [
    "convertinotlink('Count Words in String')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Count Words in String\n",
    "\n",
    "You are given a string s consisting of multiple words. You need to count the total words in the string. Words are separated by a single space.\n",
    "Note: It is guaranteed that the last character of the given string is not a white space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "def countWords(self,s):\n",
    "    s = s.split(\" \")\n",
    "    return len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "def countWords(s):\n",
    "    #code here\n",
    "    s1 = list(s)\n",
    "    count = 0\n",
    "    for i in s1:\n",
    "        if i == \" \":\n",
    "            count += 1\n",
    "    return count + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lowercase to Upercase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Solution:\n",
    "    def caseConversion(self,s):\n",
    "        return s.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Uppercase to Lowercase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Solution:\n",
    "    def caseConversion(self,s):\n",
    "       #your code here\n",
    "        return s.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate(s):\n",
    "    s1='[@_!#$%^&*()<>?/\\|}-{~:]'\n",
    "    dig =False\n",
    "    upp = False\n",
    "    low = False\n",
    "    spec= False\n",
    "    if len(s) >= 10:\n",
    "        for i in s:\n",
    "            if i.isdigit():\n",
    "                dig = True\n",
    "            if i.isupper():\n",
    "                upp = True\n",
    "            if i.islower():\n",
    "                low = True\n",
    "            if (i in s1):\n",
    "                spec = True\n",
    "    \n",
    "        if dig and upp and low and spec:\n",
    "            return 1 \n",
    "        else:\n",
    "            return 0\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pangram Checking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Solution:\n",
    "    def isPanagram(self,s):\n",
    "        #your code here\n",
    "        if len(s) <= 26:\n",
    "            return False\n",
    "        a = s.lower()\n",
    "        b = set(a)\n",
    "        letters = set('abcdefghijklmnopqrstuvwxyz')\n",
    "        c = letters.intersection(b)\n",
    "        \n",
    "        if len(c) == 26:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Missing Characters in Panagram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Solution:\n",
    "    def missingPanagram(self, s):\n",
    "        a = ord('a')\n",
    "        z = ord('z')\n",
    "        seen = [0] * (z+1)\n",
    "        \n",
    "        for i in s.lower():\n",
    "            seen[ord(i)] = 1\n",
    "            \n",
    "        i = a\n",
    "        out = ''\n",
    "        while i <= z:\n",
    "            if seen[i] == 0:\n",
    "                out += chr(i)\n",
    "            i += 1\n",
    "        \n",
    "        if out == '':\n",
    "            return -1\n",
    "        else:\n",
    "            return out"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}