Hackerrank_Trials.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HackerRank.com presents \"Pythonist 2\".\n",
      "hACKERrANK.COM PRESENTS \"pYTHONIST 2\".\n"
     ]
    }
   ],
   "source": [
    "def swap_case(s):\n",
    "    res = ''\n",
    "    for i in s:\n",
    "        if(i != ' '):\n",
    "            if(str.islower(i)):\n",
    "                res += i.upper()\n",
    "            elif(str.isupper(i)):\n",
    "                res += i.lower()\n",
    "            else:\n",
    "                res += i\n",
    "        else:\n",
    "            res += ' '\n",
    "    return res\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    s = input()\n",
    "    result = swap_case(s)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class str in module builtins:\n",
      "\n",
      "class str(object)\n",
      " |  str(object='') -> str\n",
      " |  str(bytes_or_buffer[, encoding[, errors]]) -> str\n",
      " |  \n",
      " |  Create a new string object from the given object. If encoding or\n",
      " |  errors is specified, then the object must expose a data buffer\n",
      " |  that will be decoded using the given encoding and error handler.\n",
      " |  Otherwise, returns the result of object.__str__() (if defined)\n",
      " |  or repr(object).\n",
      " |  encoding defaults to sys.getdefaultencoding().\n",
      " |  errors defaults to 'strict'.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __format__(self, format_spec, /)\n",
      " |      Return a formatted version of the string as described by format_spec.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __getnewargs__(...)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Return the size of the string in memory, in bytes.\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  capitalize(self, /)\n",
      " |      Return a capitalized version of the string.\n",
      " |      \n",
      " |      More specifically, make the first character have upper case and the rest lower\n",
      " |      case.\n",
      " |  \n",
      " |  casefold(self, /)\n",
      " |      Return a version of the string suitable for caseless comparisons.\n",
      " |  \n",
      " |  center(self, width, fillchar=' ', /)\n",
      " |      Return a centered string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  count(...)\n",
      " |      S.count(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the number of non-overlapping occurrences of substring sub in\n",
      " |      string S[start:end].  Optional arguments start and end are\n",
      " |      interpreted as in slice notation.\n",
      " |  \n",
      " |  encode(self, /, encoding='utf-8', errors='strict')\n",
      " |      Encode the string using the codec registered for encoding.\n",
      " |      \n",
      " |      encoding\n",
      " |        The encoding in which to encode the string.\n",
      " |      errors\n",
      " |        The error handling scheme to use for encoding errors.\n",
      " |        The default is 'strict' meaning that encoding errors raise a\n",
      " |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and\n",
      " |        'xmlcharrefreplace' as well as any other name registered with\n",
      " |        codecs.register_error that can handle UnicodeEncodeErrors.\n",
      " |  \n",
      " |  endswith(...)\n",
      " |      S.endswith(suffix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S ends with the specified suffix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      suffix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  expandtabs(self, /, tabsize=8)\n",
      " |      Return a copy where all tab characters are expanded using spaces.\n",
      " |      \n",
      " |      If tabsize is not given, a tab size of 8 characters is assumed.\n",
      " |  \n",
      " |  find(...)\n",
      " |      S.find(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  format(...)\n",
      " |      S.format(*args, **kwargs) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from args and kwargs.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  format_map(...)\n",
      " |      S.format_map(mapping) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from mapping.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  index(...)\n",
      " |      S.index(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found, \n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  isalnum(self, /)\n",
      " |      Return True if the string is an alpha-numeric string, False otherwise.\n",
      " |      \n",
      " |      A string is alpha-numeric if all characters in the string are alpha-numeric and\n",
      " |      there is at least one character in the string.\n",
      " |  \n",
      " |  isalpha(self, /)\n",
      " |      Return True if the string is an alphabetic string, False otherwise.\n",
      " |      \n",
      " |      A string is alphabetic if all characters in the string are alphabetic and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  isascii(self, /)\n",
      " |      Return True if all characters in the string are ASCII, False otherwise.\n",
      " |      \n",
      " |      ASCII characters have code points in the range U+0000-U+007F.\n",
      " |      Empty string is ASCII too.\n",
      " |  \n",
      " |  isdecimal(self, /)\n",
      " |      Return True if the string is a decimal string, False otherwise.\n",
      " |      \n",
      " |      A string is a decimal string if all characters in the string are decimal and\n",
      " |      there is at least one character in the string.\n",
      " |  \n",
      " |  isdigit(self, /)\n",
      " |      Return True if the string is a digit string, False otherwise.\n",
      " |      \n",
      " |      A string is a digit string if all characters in the string are digits and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  isidentifier(self, /)\n",
      " |      Return True if the string is a valid Python identifier, False otherwise.\n",
      " |      \n",
      " |      Use keyword.iskeyword() to test for reserved identifiers such as \"def\" and\n",
      " |      \"class\".\n",
      " |  \n",
      " |  islower(self, /)\n",
      " |      Return True if the string is a lowercase string, False otherwise.\n",
      " |      \n",
      " |      A string is lowercase if all cased characters in the string are lowercase and\n",
      " |      there is at least one cased character in the string.\n",
      " |  \n",
      " |  isnumeric(self, /)\n",
      " |      Return True if the string is a numeric string, False otherwise.\n",
      " |      \n",
      " |      A string is numeric if all characters in the string are numeric and there is at\n",
      " |      least one character in the string.\n",
      " |  \n",
      " |  isprintable(self, /)\n",
      " |      Return True if the string is printable, False otherwise.\n",
      " |      \n",
      " |      A string is printable if all of its characters are considered printable in\n",
      " |      repr() or if it is empty.\n",
      " |  \n",
      " |  isspace(self, /)\n",
      " |      Return True if the string is a whitespace string, False otherwise.\n",
      " |      \n",
      " |      A string is whitespace if all characters in the string are whitespace and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  istitle(self, /)\n",
      " |      Return True if the string is a title-cased string, False otherwise.\n",
      " |      \n",
      " |      In a title-cased string, upper- and title-case characters may only\n",
      " |      follow uncased characters and lowercase characters only cased ones.\n",
      " |  \n",
      " |  isupper(self, /)\n",
      " |      Return True if the string is an uppercase string, False otherwise.\n",
      " |      \n",
      " |      A string is uppercase if all cased characters in the string are uppercase and\n",
      " |      there is at least one cased character in the string.\n",
      " |  \n",
      " |  join(self, iterable, /)\n",
      " |      Concatenate any number of strings.\n",
      " |      \n",
      " |      The string whose method is called is inserted in between each given string.\n",
      " |      The result is returned as a new string.\n",
      " |      \n",
      " |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'\n",
      " |  \n",
      " |  ljust(self, width, fillchar=' ', /)\n",
      " |      Return a left-justified string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  lower(self, /)\n",
      " |      Return a copy of the string converted to lowercase.\n",
      " |  \n",
      " |  lstrip(self, chars=None, /)\n",
      " |      Return a copy of the string with leading whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  partition(self, sep, /)\n",
      " |      Partition the string into three parts using the given separator.\n",
      " |      \n",
      " |      This will search for the separator in the string.  If the separator is found,\n",
      " |      returns a 3-tuple containing the part before the separator, the separator\n",
      " |      itself, and the part after it.\n",
      " |      \n",
      " |      If the separator is not found, returns a 3-tuple containing the original string\n",
      " |      and two empty strings.\n",
      " |  \n",
      " |  replace(self, old, new, count=-1, /)\n",
      " |      Return a copy with all occurrences of substring old replaced by new.\n",
      " |      \n",
      " |        count\n",
      " |          Maximum number of occurrences to replace.\n",
      " |          -1 (the default value) means replace all occurrences.\n",
      " |      \n",
      " |      If the optional argument count is given, only the first count occurrences are\n",
      " |      replaced.\n",
      " |  \n",
      " |  rfind(...)\n",
      " |      S.rfind(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  rindex(...)\n",
      " |      S.rindex(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  rjust(self, width, fillchar=' ', /)\n",
      " |      Return a right-justified string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  rpartition(self, sep, /)\n",
      " |      Partition the string into three parts using the given separator.\n",
      " |      \n",
      " |      This will search for the separator in the string, starting at the end. If\n",
      " |      the separator is found, returns a 3-tuple containing the part before the\n",
      " |      separator, the separator itself, and the part after it.\n",
      " |      \n",
      " |      If the separator is not found, returns a 3-tuple containing two empty strings\n",
      " |      and the original string.\n",
      " |  \n",
      " |  rsplit(self, /, sep=None, maxsplit=-1)\n",
      " |      Return a list of the words in the string, using sep as the delimiter string.\n",
      " |      \n",
      " |        sep\n",
      " |          The delimiter according which to split the string.\n",
      " |          None (the default value) means split according to any whitespace,\n",
      " |          and discard empty strings from the result.\n",
      " |        maxsplit\n",
      " |          Maximum number of splits to do.\n",
      " |          -1 (the default value) means no limit.\n",
      " |      \n",
      " |      Splits are done starting at the end of the string and working to the front.\n",
      " |  \n",
      " |  rstrip(self, chars=None, /)\n",
      " |      Return a copy of the string with trailing whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  split(self, /, sep=None, maxsplit=-1)\n",
      " |      Return a list of the words in the string, using sep as the delimiter string.\n",
      " |      \n",
      " |      sep\n",
      " |        The delimiter according which to split the string.\n",
      " |        None (the default value) means split according to any whitespace,\n",
      " |        and discard empty strings from the result.\n",
      " |      maxsplit\n",
      " |        Maximum number of splits to do.\n",
      " |        -1 (the default value) means no limit.\n",
      " |  \n",
      " |  splitlines(self, /, keepends=False)\n",
      " |      Return a list of the lines in the string, breaking at line boundaries.\n",
      " |      \n",
      " |      Line breaks are not included in the resulting list unless keepends is given and\n",
      " |      true.\n",
      " |  \n",
      " |  startswith(...)\n",
      " |      S.startswith(prefix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S starts with the specified prefix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      prefix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  strip(self, chars=None, /)\n",
      " |      Return a copy of the string with leading and trailing whitespace remove.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  swapcase(self, /)\n",
      " |      Convert uppercase characters to lowercase and lowercase characters to uppercase.\n",
      " |  \n",
      " |  title(self, /)\n",
      " |      Return a version of the string where each word is titlecased.\n",
      " |      \n",
      " |      More specifically, words start with uppercased characters and all remaining\n",
      " |      cased characters have lower case.\n",
      " |  \n",
      " |  translate(self, table, /)\n",
      " |      Replace each character in the string using the given translation table.\n",
      " |      \n",
      " |        table\n",
      " |          Translation table, which must be a mapping of Unicode ordinals to\n",
      " |          Unicode ordinals, strings, or None.\n",
      " |      \n",
      " |      The table must implement lookup/indexing via __getitem__, for instance a\n",
      " |      dictionary or list.  If this operation raises LookupError, the character is\n",
      " |      left untouched.  Characters mapped to None are deleted.\n",
      " |  \n",
      " |  upper(self, /)\n",
      " |      Return a copy of the string converted to uppercase.\n",
      " |  \n",
      " |  zfill(self, width, /)\n",
      " |      Pad a numeric string with zeros on the left, to fill a field of the given width.\n",
      " |      \n",
      " |      The string is never truncated.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  maketrans(x, y=None, z=None, /)\n",
      " |      Return a translation table usable for str.translate().\n",
      " |      \n",
      " |      If there is only one argument, it must be a dictionary mapping Unicode\n",
      " |      ordinals (integers) or characters to Unicode ordinals, strings or None.\n",
      " |      Character keys will be then converted to ordinals.\n",
      " |      If there are two arguments, they must be strings of equal length, and\n",
      " |      in the resulting dictionary, each character in x will be mapped to the\n",
      " |      character at the same position in y. If there is a third argument, it\n",
      " |      must be a string, whose characters will be mapped to None in the result.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a string   \n",
      "this-is-a-string\n"
     ]
    }
   ],
   "source": [
    "def split_and_join(line):\n",
    "    a = line.strip()\n",
    "    a = a.split(\" \")\n",
    "    a = \"-\".join(a)\n",
    "    return a\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    line = input()\n",
    "    result = split_and_join(line)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ross\n",
      "Taylor\n",
      "Hello Ross Taylor! You just delved into python.\n"
     ]
    }
   ],
   "source": [
    "def print_full_name(a, b):\n",
    "    print(f\"Hello {a} {b}! You just delved into python.\")\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    first_name = input()\n",
    "    last_name = input()\n",
    "    print_full_name(first_name, last_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abracadabra\n",
      "5 k\n",
      "abrackdabra\n"
     ]
    }
   ],
   "source": [
    "def mutate_string(string, position, character):\n",
    "    res = ''\n",
    "    for i in range(len(string)):\n",
    "        if(i == position):\n",
    "            res += character\n",
    "        else:\n",
    "            res += string[i]\n",
    "    return res\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    s = input()\n",
    "    i, c = input().split()\n",
    "    s_new = mutate_string(s, int(i), c)\n",
    "    print(s_new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABCDCDC\n",
      "CDC\n",
      "\n",
      "CDC\n",
      "CDC\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "def count_substring(string, sub_string):\n",
    "    ctr = 0\n",
    "    for i in range(0,len(string)-len(sub_string)+1):\n",
    "        if(string[i:i+len(sub_string)] == sub_string):\n",
    "            ctr += 1\n",
    "    return ctr\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    string = input().strip()\n",
    "    sub_string = input().strip()\n",
    "    count = count_substring(string, sub_string)\n",
    "    print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def checkAlphaNum(s):\n",
    "    for i in s:\n",
    "        if(i.isalnum()):\n",
    "            return True\n",
    "    return False\n",
    "def checkAlpha(s):\n",
    "    for i in s:\n",
    "        if(i.isalpha()):\n",
    "            return True\n",
    "    return False\n",
    "def checkDigit(s):\n",
    "    for i in s:\n",
    "        if(i.isdigit()):\n",
    "            return True\n",
    "    return False\n",
    "def checkLower(s):\n",
    "    for i in s:\n",
    "        if(i.islower()):\n",
    "            return True\n",
    "    return False\n",
    "def checkUpper(s):\n",
    "    for i in s:\n",
    "        if(i.isupper()):\n",
    "            return True\n",
    "    return False\n",
    "        \n",
    "\n",
    "if __name__ == '__main__':\n",
    "    s = input()\n",
    "    print(checkAlphaNum(s))\n",
    "    print(checkAlpha(s))\n",
    "    print(checkDigit(s))\n",
    "    print(checkLower(s))\n",
    "    print(checkUpper(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "      H      \n",
      "     HHH     \n",
      "    HHHHH    \n",
      "   HHHHHHH   \n",
      "  HHHHHHHHH  \n",
      " HHHHHHHHHHH \n",
      "HHHHHHHHHHHHH\n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH    \n",
      "   HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH    \n",
      "   HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH    \n",
      "   HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH    \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "   HHHHHHH                     HHHHHHH                  \n",
      "                            HHHHHHHHHHHHH \n",
      "                             HHHHHHHHHHH  \n",
      "                              HHHHHHHHH   \n",
      "                               HHHHHHH    \n",
      "                                HHHHH     \n",
      "                                 HHH      \n",
      "                                  H       \n"
     ]
    }
   ],
   "source": [
    "#Replace all ______ with rjust, ljust or center. \n",
    "\n",
    "thickness = int(input()) #This must be an odd number\n",
    "c = 'H'\n",
    "\n",
    "#Top Cone\n",
    "for i in range(thickness):\n",
    "    print((c*i).rjust(thickness-1)+c+(c*i).ljust(thickness-1))\n",
    "\n",
    "#Top Pillars\n",
    "for i in range(thickness+1):\n",
    "    print((c*thickness).center(thickness*2)+(c*thickness).center(thickness*6))\n",
    "\n",
    "#Middle Belt\n",
    "for i in range((thickness+1)//2):\n",
    "    print((c*thickness*5).center(thickness*6))    \n",
    "\n",
    "#Bottom Pillars\n",
    "for i in range(thickness+1):\n",
    "    print((c*thickness).center(thickness*2)+(c*thickness).center(thickness*6))    \n",
    "\n",
    "#Bottom Cone\n",
    "for i in range(thickness):\n",
    "    print(((c*(thickness-i-1)).rjust(thickness)+c+(c*(thickness-i-1)).ljust(thickness)).rjust(thickness*6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABCDEFGHIJKLIMNOQRSTUVWXYZ\n",
      "4\n",
      "ABCD\n",
      "EFGH\n",
      "IJKL\n",
      "IMNO\n",
      "QRST\n",
      "UVWX\n",
      "YZ\n"
     ]
    }
   ],
   "source": [
    "import textwrap\n",
    "\n",
    "def wrap(string, max_width):\n",
    "    return textwrap.fill(string,max_width)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    string, max_width = input(), int(input())\n",
    "    result = wrap(string, max_width)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kevin 86752\n"
     ]
    }
   ],
   "source": [
    "def minion_game(string):\n",
    "    s1 = s2 =string\n",
    "    ssc = []\n",
    "    ksv = []\n",
    "    for ch in string:\n",
    "        if(ch=='A' or ch=='a' or ch=='E' or ch =='e' or ch=='I'\n",
    "           or ch=='i' or ch=='O' or ch=='o' or ch=='U' or ch=='u'):\n",
    "            if(ch not in ksv):\n",
    "                ksv.append(ch)\n",
    "        else:\n",
    "            if(ch not in ssc):\n",
    "                ssc.append(ch)\n",
    "    finResStuart = []\n",
    "    finResKevin = []\n",
    "    for ctr in range(1,len(s1)+1):\n",
    "        q = []\n",
    "        for i in ssc:\n",
    "            for j in range(0,len(s1)):\n",
    "                if(s1[j:j+ctr].startswith(i)):\n",
    "                    if(len(s1[j:j+ctr]) == ctr):\n",
    "                        if(s1[j:j+ctr] not in q):\n",
    "                            q.append(s1[j:j+ctr])\n",
    "        if(len(q) != 0):\n",
    "            finResStuart.append(q.copy())\n",
    "        \n",
    "    for ctr in range(1,len(s2)+1):\n",
    "        q = []\n",
    "        for i in ksv:\n",
    "            for j in range(0,len(s2)):\n",
    "                if(s2[j:j+ctr].startswith(i)):\n",
    "                    if(len(s2[j:j+ctr]) == ctr):\n",
    "                        if(s2[j:j+ctr] not in q):\n",
    "                            q.append(s2[j:j+ctr])\n",
    "        if(len(q) != 0):\n",
    "            finResKevin.append(q.copy())\n",
    "    stuart = {}\n",
    "    kevin = {}\n",
    "    for i in finResStuart:\n",
    "        for j in i:\n",
    "            stuart[j] = s1.count(j)\n",
    "    for i in finResKevin:\n",
    "        for j in i:\n",
    "            kevin[j] = s2.count(j)\n",
    "    \n",
    "    if(sum(kevin.values()) > sum(stuart.values())):\n",
    "        print(f\"Kevin {sum(kevin.values())}\")\n",
    "    elif(sum(kevin.values()) < sum(stuart.values())):\n",
    "        print(f\"Stuart {sum(stuart.values())}\")\n",
    "            \n",
    "if __name__ == '__main__':\n",
    "    s = input()\n",
    "    minion_game(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "# help(str.split)\n",
    "wq1 = \"BANANA\"\n",
    "qq = ['A']\n",
    "q = []\n",
    "i = 0\n",
    "ctr = 6\n",
    "for i in qq:\n",
    "#     print(\"i:\",i,\"\\n\")\n",
    "    for j in range(0,len(wq1)):\n",
    "#         print(\"j:\",j,\"\\n\")\n",
    "        if(wq1[j:j+ctr].startswith(i)):\n",
    "#             print(\"wq1[j:j+ctr]:\",wq1[j:j+ctr],\"\\n\")\n",
    "            if(len(wq1[j:j+ctr]) == ctr):\n",
    "#                 print(\"len(wq1[j:j+ctr]):\",len(wq1[j:j+ctr]),\"\\n\")\n",
    "                if(wq1[j:j+ctr] not in q):\n",
    "#                     print(\"wq1[j:j+ctr]:\",wq1[j:j+ctr],\"\\n\")\n",
    "#                     print(\"q\",q,\"\\n\")\n",
    "                    q.append(wq1[j:j+ctr])\n",
    "print(q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'kevin' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-107-3d87b5149e0c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkevin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'kevin' is not defined"
     ]
    }
   ],
   "source": [
    "print(sum(kevin.values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n",
      "3 4\n",
      "(1, 3) (1, 4) (2, 3) (2, 4) "
     ]
    }
   ],
   "source": [
    "from itertools import product\n",
    "inp1 = input().split(' ')\n",
    "inp2 = input().split(' ')\n",
    "ii1 = []\n",
    "ii2 = []\n",
    "for i in inp1:\n",
    "    ii1.append(int(i))\n",
    "for i in inp2:\n",
    "    ii2.append(int(i))\n",
    "prodd = list(product(ii1,ii2))\n",
    "for i in prodd:\n",
    "    print(i,end=\" \")\n",
    "# print(list(product(ii1,ii2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "add 1\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# !/bin/python3\n",
    "\n",
    "import math\n",
    "import os\n",
    "import random\n",
    "import re\n",
    "import sys\n",
    "\n",
    "\n",
    "class Multiset:\n",
    "\n",
    "    def add(self, val):\n",
    "        # adds one occurrence of val from the multiset, if any\n",
    "        result.append(val)\n",
    "        pass\n",
    "\n",
    "    def remove(self, val):\n",
    "        # removes one occurrence of val from the multiset, if any\n",
    "        pass\n",
    "\n",
    "    def __contains__(self, val):\n",
    "        # returns True when val is in the multiset, else returns False\n",
    "        return False\n",
    "    \n",
    "    def __len__(self):\n",
    "        # returns the number of elements in the multiset\n",
    "        return 0\n",
    "if __name__ == '__main__':\n",
    "    def performOperations(operations):\n",
    "        m = Multiset()\n",
    "        result = []\n",
    "        for op_str in operations:\n",
    "            elems = op_str.split()\n",
    "            if elems[0] == 'size':\n",
    "                result.append(len(m))\n",
    "            else:\n",
    "                op, val = elems[0], int(elems[1])\n",
    "                if op == 'query':\n",
    "                    result.append(val in m)\n",
    "                elif op == 'add': \n",
    "                    m.add(val)\n",
    "                elif op == 'remove':\n",
    "                    m.remove(val)\n",
    "        return result\n",
    "\n",
    "    q = int(input())\n",
    "    operations = []\n",
    "    for _ in range(q):\n",
    "        operations.append(input())\n",
    "\n",
    "    result = performOperations(operations)\n",
    "\n",
    "    print('\\n'.join(map(str, result)))\n",
    "    print('\\n')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}