Subjective Assignment - 1- Python core.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Write a Python program to get the string from the given string where\n",
    "all the occurrence of its first char has been changed to '$,' except first\n",
    "char itself?\n",
    "\n",
    "    Sample String: 'prospect'\n",
    "    Expected Result : 'pros$ect'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter word prospect\n",
      "pros$ect\n"
     ]
    }
   ],
   "source": [
    "word = input('Enter word ')\n",
    "print(word[0] + word[1:].replace(word[0], '$'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Write a Python program to get the single string from the two given\n",
    "strings, and separated by the space and swap the first two characters of\n",
    "each string?\n",
    "\n",
    "    Sample String : 'abc', 'xyz'.\n",
    "    Expected Result: 'xyc abz'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter 1st string: abc\n",
      "Enter 2nd string: xyz\n",
      "xyc abz\n"
     ]
    }
   ],
   "source": [
    "word1 = input('Enter 1st string: ')\n",
    "word2 = input('Enter 2nd string: ')\n",
    "sentence = word2[:2] + word1[2:] +' ' + word1[:2] + word2[2:]\n",
    "print(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Write the Python program to add 'ing' at the end of the given string\n",
    "(length of the string should be at least 3). If given string already ends\n",
    "with 'ing,' then add 'ly' instead. If string length of the given string is less\n",
    "than 3, leave it unchanged?\n",
    "\n",
    "\n",
    "    Sample string: ' abc '\n",
    "    Expected result: ' abcing '\n",
    "    Sample string: ' string '\n",
    "    Expected result: ' stringly '\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter word abc\n",
      "abcing\n"
     ]
    }
   ],
   "source": [
    "word = input('Enter word ')\n",
    "if word[-3:] == 'ing':\n",
    "    print(word + 'ly')\n",
    "else:\n",
    "    print(word + 'ing')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Write the Python program to find the first appearance of the\n",
    "substring 'not' and 'poor' from the given string, if 'not' follows the 'poor',\n",
    "replace the whole 'not'...' poor' substring with 'good'.Return the resulting\n",
    "string.\n",
    "\n",
    "    Sample string: 'The lyrics are not that poor!'\n",
    "    'The lyrics are poor!'\n",
    "    Expected Result: 'The lyrics are good!'\n",
    "    'The lyrics are poor!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: The lyrics are not that poor!\n",
      "The lyrics are good!\n"
     ]
    }
   ],
   "source": [
    "sentence = input('Enter a sentence: ')\n",
    "s_not = sentence.find('not')\n",
    "s_poor = sentence.find('poor')\n",
    "\n",
    "if s_poor > s_not and s_not != -1 and s_poor != -1:\n",
    "    sentence = sentence.replace(sentence[s_not:(s_poor+4)], 'good')\n",
    "print(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Write the Python program to remove the characters which have odd\n",
    "index values of a given string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: Shreya\n",
      "Sry\n"
     ]
    }
   ],
   "source": [
    "sen = input('Enter a string: ')\n",
    "print(sen[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q6. Write the python program to print the following floating numbers up\n",
    "to 2 decimal places?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number3.14159\n",
      "Rounded number 3.14\n"
     ]
    }
   ],
   "source": [
    "num = float(input('Enter a number'))\n",
    "print('Rounded number', round(num, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7. Write the Python program to format a number with a percentage?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 29 states in india\n"
     ]
    }
   ],
   "source": [
    "print('There are {} states in india'.format(29))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8. Write the Python program to count occurrences of a substring in a\n",
    "String?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: test test test\n",
      "String to be searched: test\n",
      "[0, 5, 10]\n"
     ]
    }
   ],
   "source": [
    "sen = input('Enter a string: ')\n",
    "sub = input('String to be searched: ')\n",
    "start = 0\n",
    "l = []\n",
    "while True:\n",
    "    start = sen.find(sub, start)\n",
    "    if start == -1:\n",
    "        break\n",
    "    l.append(start)\n",
    "    start += len(sub)\n",
    "print(l)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Write the Python program to count repeated characters in a string.\n",
    "\n",
    "    Sample string: ' thequickbrownjumpsoverthelazydog '\n",
    "    \n",
    "    Expected output:\n",
    "    o 3\n",
    "    e 3\n",
    "    u 2\n",
    "    h 2\n",
    "    r 2\n",
    "    t 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o 4\n",
      "e 3\n",
      "t 2\n",
      "h 2\n",
      "u 2\n",
      "r 2\n"
     ]
    }
   ],
   "source": [
    "import collections\n",
    "str1 = 'thequickbrownfoxjumpsoverthelazydog'\n",
    "d = collections.defaultdict(int)\n",
    "for c in str1:\n",
    "    d[c] += 1\n",
    "\n",
    "for c in sorted(d, key=d.get, reverse=True):\n",
    "  if d[c] > 1:\n",
    "    print('%s %d' % (c, d[c]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q10. Write the Python program to print the square and cube symbol in\n",
    "the area of a rectangle and volume of a cylinder?\n",
    "\n",
    "    Sample outputThe area of the rectangle is 1256.66cm2\n",
    "    The volume of the cylinder is 1254.725cm3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The area of the rectangle is 1256.66 cm²\n",
      "The volume of the cylinder is 1254.725 cm³\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "area = 1256.66\n",
    "volume = 1254.725\n",
    "print('The area of the rectangle is {} cm\\u00b2'.format(area))\n",
    "print('The volume of the cylinder is {} cm\\u00b3'.format(volume))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. Write the Python program to check if a string contains all letters of\n",
    "the alphabet?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter sentence: abcdefg\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "alphabet = set(string.ascii_lowercase)\n",
    "input_string = input('Enter sentence: ')\n",
    "print(set(input_string.lower()) >= alphabet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q12. Write the Python program to find the second most repeated word\n",
    "in a given string?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter string: Both of these issues are fixed by postponing the evaluation of annotations. Instead of compiling code which executes expressions in annotations at their definition time, the compiler stores the annotation in a string form equivalent to the AST of the expression in question. If needed, annotations can be resolved at runtime using typing.get_type_hints(). In the common case where this is not required, the annotations are cheaper to store (since short strings are interned by the interpreter) and make startup time faster.\n",
      "('of', 4)\n"
     ]
    }
   ],
   "source": [
    "string = input('Enter string: ')\n",
    "count = dict()\n",
    "sen = string.split(' ')\n",
    "for word in sen:\n",
    "    if word in count: \n",
    "        count[word] += 1\n",
    "    else:\n",
    "        count[word] = 1\n",
    "\n",
    "counts_x = sorted(count.items(), key=lambda kv: kv[1])\n",
    "print(counts_x[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q13. Write the Python program to find the minimum window in the given\n",
    "string, which will contains all the characters of another given\n",
    "strings?\n",
    "\n",
    "    Example 1\n",
    "    Input : string1 = \" PRWSOERIUSFK \"\n",
    "    string2 = \" OSU \"\n",
    "    Output: Minimum window is \"OERIUS\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Strings:\n",
      " asdaewsqgtwwsa\n",
      "\n",
      "Smallest window that contains all characters of the said string:\n",
      "daewsqgt\n"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict   \n",
    "\n",
    "def find_sub_string(str): \n",
    "    str_len = len(str) \n",
    "      \n",
    "    # Count all distinct characters. \n",
    "    dist_count_char = len(set([x for x in str])) \n",
    "  \n",
    "    ctr, start_pos, start_pos_index, min_len = 0, 0, -1, 9999999999\n",
    "    curr_count = defaultdict(lambda: 0) \n",
    "    for i in range(str_len): \n",
    "        curr_count[str[i]] += 1\n",
    " \n",
    "        if curr_count[str[i]] == 1: \n",
    "            ctr += 1\n",
    "  \n",
    "        if ctr == dist_count_char: \n",
    "            while curr_count[str[start_pos]] > 1: \n",
    "                if curr_count[str[start_pos]] > 1: \n",
    "                    curr_count[str[start_pos]] -= 1\n",
    "                start_pos += 1\n",
    "  \n",
    "            len_window = i - start_pos + 1\n",
    "            if min_len > len_window: \n",
    "                min_len = len_window \n",
    "                start_pos_index = start_pos \n",
    "    return str[start_pos_index: start_pos_index + min_len] \n",
    "      \n",
    "str1 = \"asdaewsqgtwwsa\"\n",
    "print(\"Original Strings:\\n\",str1)\n",
    "print(\"\\nSmallest window that contains all characters of the said string:\")\n",
    "print(find_sub_string(str1)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q14. Write the Python program to count number of substrings from a\n",
    "given string of lowercase alphabets with exactly k distinct (given)\n",
    "characters?\n",
    "\n",
    "    Input a string (lowercase alphabets): wolf\n",
    "    Input k: 4\n",
    "    Number of substrings with exactly 4 distinct characters: 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input a string (lowercase alphabets):wolf\n",
      "Input k: 4\n",
      "Number of substrings with exactly 4 distinct characters : 1\n"
     ]
    }
   ],
   "source": [
    "def count_k_dist(str1, k): \n",
    "    str_len = len(str1) \n",
    "\n",
    "    result = 0\n",
    "\n",
    "    ctr = [0] * 27\n",
    "\n",
    "    for i in range(0, str_len): \n",
    "        dist_ctr = 0\n",
    "\n",
    "        ctr = [0] * 27\n",
    "\n",
    "        for j in range(i, str_len): \n",
    "\n",
    "            if(ctr[ord(str1[j]) - 97] == 0): \n",
    "                dist_ctr += 1\n",
    "\n",
    "            ctr[ord(str1[j]) - 97] += 1\n",
    "\n",
    "            if(dist_ctr == k): \n",
    "                result += 1\n",
    "            if(dist_ctr > k): \n",
    "                break\n",
    "\n",
    "    return result \n",
    "\n",
    "str1 = input(\"Input a string (lowercase alphabets):\")\n",
    "k = int(input(\"Input k: \"))\n",
    "print(\"Number of substrings with exactly\", k, \"distinct characters : \", end = \"\") \n",
    "print(count_k_dist(str1, k))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q15. Write the Python program to count number of substrings with same\n",
    "first and last characters of the given string?\n",
    "\n",
    "    Input a string: abcd\n",
    "    4\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter string: abcd\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "string = input('Enter string: ')\n",
    "res = 0\n",
    "for i in range(len(string)):\n",
    "    for j in range(i, len(string)):\n",
    "        if string[i] == string[j]:\n",
    "            res += 1\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Great Job!"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}