Week_3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GPA 1\n",
    "Write a program to find the sum of the following series up to n terms\n",
    "$$1 + (1+2) + (1+2+3) + (1+2+3+4).... n_{terms} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "10"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "sum, seriesSum = 0, 0\n",
    "\n",
    "for i in range(1, n+1): \n",
    "    seriesSum += i\n",
    "    sum += seriesSum \n",
    "print(sum, end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GPA 2\n",
    "Write a program to find all the prime factors of a number which taken as input from user. Assume the accepted integer which is greater than or equal to 2. \n",
    "<br/>\n",
    "<pre>\n",
    "<b>Sample Input 1</b>\n",
    "15\n",
    "<b>Sample Output 1</b>\n",
    "3\n",
    "5\n",
    "<b>Sample Input 2</b>\n",
    "79\n",
    "<b>Sample Output 2</b>\n",
    "79\n",
    "<b>Sample Input 3</b>\n",
    "78\n",
    "<b>Sample Output 3</b>\n",
    "2\n",
    "3\n",
    "13\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78\n",
      "2\n",
      "3\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "\n",
    "for i in range(2, n+1): \n",
    "    isPrime = 1\n",
    "    for j in range(2, i): \n",
    "        if i % j == 0: \n",
    "            isPrime = 0\n",
    "    if isPrime and n%i == 0: \n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GPA 3\n",
    "Accept a string as an input from the user, conver this to lower case and print the string in ascending order using loop. \n",
    "<br/>\n",
    "<pre>\n",
    "<b>Sample Input 1</b>\n",
    "Bharatanatyam\n",
    "<b>Sample Output 1</b>\n",
    "aaaaabhmnrtty\n",
    "<b>Sample Input 2</b>\n",
    "monty python\n",
    "<b>Sample Output 2</b>\n",
    "hmnnoopttyy\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "monty python\n",
      "hmnnoopttyy"
     ]
    }
   ],
   "source": [
    "a = input()\n",
    "a = a.lower()\n",
    "output = \"\"\n",
    "n = len(a)\n",
    "for i in range(n):\n",
    "    if a[i].isalpha() == True: \n",
    "        j = len(output)-1\n",
    "        while j >= 0 and output[j] > a[i]:\n",
    "            j -= 1\n",
    "        output = output[:j+1] + a[i] + output[j+1: ]\n",
    "            \n",
    "print(output, end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GPA 4\n",
    "Accept the string from the user and display the characters located on prime index (2, 3, 5, 6...) of a given string. \n",
    "<pre>\n",
    "<b>Sample Input 1</b>\n",
    "hellopython\n",
    "<b>Sample Output 1</b>\n",
    "l\n",
    "l\n",
    "p\n",
    "t\n",
    "<b>Sample Input 2</b>\n",
    "this is python program\n",
    "<b>Sample Output 2</b>\n",
    "i\n",
    "s\n",
    "i\n",
    "\n",
    "h\n",
    "n\n",
    "o\n",
    "r\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is python program\n",
      "i\n",
      "s\n",
      "i\n",
      " \n",
      "h\n",
      "n\n",
      "o\n",
      "r\n"
     ]
    }
   ],
   "source": [
    "inp = input()\n",
    "for i in range(2, len(inp)): \n",
    "    flag = 1\n",
    "    for j in range(2, i): \n",
    "        if i%j == 0: \n",
    "            flag = 0\n",
    "    if flag: \n",
    "        print(inp[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GPA 5\n",
    "Accept phone number from user as string. <br/>\n",
    "A valid phone number should satisfy the following constraints. \n",
    "1. The number should start with 6, 7, 8 and 9\n",
    "2. Length of the number should be 10 \n",
    "3. Number should not have any digit repeated more then 5 times in consecutive manner. \n",
    "4. Number should not have any digit more than 7times. \n",
    "| Input | Output|\n",
    "| --- | --- |\n",
    "| 9852546666 | valid |\n",
    "| 0984587558 | invalid |\n",
    "| 85425@6558 | invalid | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0984587558\n",
      "invalid"
     ]
    }
   ],
   "source": [
    "number = input()\n",
    "flag = number.isnumeric()\n",
    "if not(number[0] in \"6789\") or len(number) != 10: \n",
    "    flag = 0\n",
    "if flag: \n",
    "    for i in range(10): \n",
    "        if number.count(str(i)) >= 7: \n",
    "            flag = 0\n",
    "            break\n",
    "\n",
    "if flag: \n",
    "    for i in range(len(number)): \n",
    "        if number[i: (i+5)%len(number)] == number[i]*5: \n",
    "            flag = 0\n",
    "            break\n",
    "            \n",
    "if flag: \n",
    "    print(\"valid\", end=\"\")\n",
    "else: \n",
    "    print('invalid', end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PPA 1\n",
    "Write a program to print the numbers which are divisible by 12 and 13 in range of ```[1000 - 2000]```\n",
    "\n",
    "**Output**\n",
    "<pre>\n",
    "1092\n",
    "1248\n",
    "1404\n",
    "1560\n",
    "1716\n",
    "1872\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PPA 2\n",
    "Write a program to find the sum of the digits of the number got from the user.\n",
    "\n",
    "<table style=\"\" style=\"width: 100%; text-transform: capitalize; border: 1px solid black;\">\n",
    "<thead>\n",
    "<tr style=\"height: 34px; text-align: left; \">\n",
    "<td style=\"width: 122px; height: 34px; text-align: center;border: 1px solid black;\">Input</td>\n",
    "<td style=\"width: 123px; height: 34px;text-align: center;border: 1px solid black;\">Output</td>\n",
    "</tr>\n",
    "</thead>\n",
    "\n",
    "<tbody>\n",
    "<tr style=\"height: 34px;\">\n",
    "<td style=\"width: 122px; height: 34px;text-align: center;border: 1px solid black;\">123456</td>\n",
    "<td style=\"width: 123px; height: 34px;text-align: center;border: 1px solid black;\">21</td>\n",
    "</tr>\n",
    "<tr style=\"height: 34px;\">\n",
    "<td style=\"width: 122px; height: 34px;text-align: center;border: 1px solid black;\">67127</td>\n",
    "<td style=\"width: 123px; height: 34px;text-align: center;border: 1px solid black;\">23</td>\n",
    "</tr>\n",
    "<tr style=\"height: 34px;\">\n",
    "<td style=\"width: 122px; height: 34px;text-align: center;border: 1px solid black;\">182638</td>\n",
    "<td style=\"width: 123px; height: 34px;text-align: center;border: 1px solid black;\">28</td>\n",
    "</tr>\n",
    "</tbody>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PPA 3\n",
    "Write a program to find sum of all prime numbers between 1 to n , where n is a positive integer from user.\n",
    "\n",
    "<table style=\"\" style=\"width: 100%; text-transform: capitalize; border: 1px solid black;\">\n",
    "<thead>\n",
    "<tr style=\"height: 34px; text-align: left; \">\n",
    "<td style=\"width: 122px; height: 34px; text-align: center;border: 1px solid black;\">Input</td>\n",
    "<td style=\"width: 123px; height: 34px;text-align: center;border: 1px solid black;\">Output</td>\n",
    "</tr>\n",
    "</thead>\n",
    "\n",
    "<tbody>\n",
    "<tr style=\"height: 34px;\">\n",
    "<td style=\"width: 122px; height: 34px;text-align: center;border: 1px solid black;\">10</td>\n",
    "<td style=\"width: 123px; height: 34px;text-align: center;border: 1px solid black;\">17</td>\n",
    "</tr>\n",
    "<tr style=\"height: 34px;\">\n",
    "<td style=\"width: 122px; height: 34px;text-align: center;border: 1px solid black;\">100</td>\n",
    "<td style=\"width: 123px; height: 34px;text-align: center;border: 1px solid black;\">1060</td>\n",
    "</tr>\n",
    "\n",
    "</tbody>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PPA 4\n",
    "<pre>\n",
    "Write a python program to print the following patter. The number of * in the first line taken from the user input (odd number). \n",
    "The example is given for the user input 15.\n",
    "\n",
    "</pre>\n",
    "\n",
    "**Test case 1:**\n",
    "<pre><b>Input: </b>\n",
    "15\n",
    "<b>Output</b>\n",
    "***************\n",
    "**     *     **\n",
    "* *    *    * *\n",
    "*  *   *   *  *\n",
    "*   *  *  *   *\n",
    "*    * * *    *\n",
    "*     ***     *\n",
    "***************\n",
    "*     ***     *\n",
    "*    * * *    *\n",
    "*   *  *  *   *\n",
    "*  *   *   *  *\n",
    "* *    *    * *\n",
    "**     *     **\n",
    "***************\n",
    "\n",
    "</pre>\n",
    "**Test case 2:**\n",
    "<pre><b>Input: </b>\n",
    "13\n",
    "<b>Output</b>\n",
    "*************\n",
    "**    *    **\n",
    "* *   *   * *\n",
    "*  *  *  *  *\n",
    "*   * * *   *\n",
    "*    ***    *\n",
    "*************\n",
    "*    ***    *\n",
    "*   * * *   *\n",
    "*  *  *  *  *\n",
    "* *   *   * *\n",
    "**    *    **\n",
    "*************\n",
    "</pre>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Try"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PPA 5\n",
    "Write a python program to print all the combination that satisfies $x^4 + y^3 = z^2$. \n",
    "Where, \n",
    "1. $x, y, z$ should be distinct, positive and less than n obtained from the user\n",
    "2. $x < y < z$\n",
    "3. The output should be printed in the ascending order of $x$. \n",
    "\n",
    ">Hint: Use nested loop.\n",
    "\n",
    "**Test Case 1**\n",
    "<pre>\n",
    "<b>Input</b>\n",
    "100\n",
    "<b>Output</b>\n",
    "1 2 3\n",
    "5 6 29\n",
    "6 9 45\n",
    "7 15 76\n",
    "</pre>\n",
    "**Test Case 2**\n",
    "<pre>\n",
    "<b>Input</b>\n",
    "10\n",
    "<b>Output</b>\n",
    "1 2 3\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PPA 6\n",
    "Accept the two strings from the user and remove all characters from the second string which are present in the first string. \n",
    "\n",
    "**Test Case 1**\n",
    "<pre>\n",
    "<b>Input</b>\n",
    "aeiou\n",
    "this is python program\n",
    "<b>Output</b>\n",
    "ths s pythn prgrm\n",
    "</pre>\n",
    "**Test Case 2**\n",
    "<pre>\n",
    "<b>Input</b>\n",
    "lo\n",
    "hello python\n",
    "<b>Output</b>\n",
    "he pythn\n",
    "</pre>\n",
    "**Test Case 3**\n",
    "<pre>\n",
    "<b>Input</b>\n",
    "a\n",
    "hello python\n",
    "<b>Output</b>\n",
    "hello python\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SOLUTIONS\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PPA 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1092\n",
      "1248\n",
      "1404\n",
      "1560\n",
      "1716\n",
      "1872\n"
     ]
    }
   ],
   "source": [
    "for i in range(1000, 2001): \n",
    "    if (i%12) == 0 and (i%13) == 0: \n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PPA 2**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123456\n",
      "21"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "sum = 0\n",
    "while n: \n",
    "    sum += n%10\n",
    "    n //= 10\n",
    "print(sum, end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PPA 3**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "17"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "sum = 0\n",
    "for i in range(2, n+1): \n",
    "    flag = True\n",
    "    for j in range(2, i): \n",
    "        if i%j == 0: \n",
    "            flag = False\n",
    "            break; \n",
    "    if flag: \n",
    "        sum += i\n",
    "print(sum, end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PPA 4**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "*************\n",
      "**    *    **\n",
      "* *   *   * *\n",
      "*  *  *  *  *\n",
      "*   * * *   *\n",
      "*    ***    *\n",
      "*************\n",
      "*    ***    *\n",
      "*   * * *   *\n",
      "*  *  *  *  *\n",
      "* *   *   * *\n",
      "**    *    **\n",
      "*************\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "if n == 1: \n",
    "    print(\"*\")\n",
    "else: \n",
    "    print(\"*\"*n)\n",
    "    for i in range((n-3)//2): \n",
    "        print(\"*\", end=\"\")\n",
    "        print(\" \"*i, end=\"\")\n",
    "        print(\"*\", end=\"\")\n",
    "        print(\" \"*((n-5)//2-i), end=\"\")\n",
    "        print(\"*\", end=\"\")\n",
    "        print(\" \"*((n-5)//2-i), end=\"\")\n",
    "        print(\"*\", end=\"\")\n",
    "        print(\" \"*i, end=\"\")\n",
    "        print(\"*\")    \n",
    "    print(\"*\"*n)\n",
    "\n",
    "    for i in range((n-3)//2): \n",
    "        print(\"*\", end=\"\")\n",
    "        print(\" \"*((n-5)//2 - i), end=\"\")\n",
    "        print(\"*\", end=\"\")\n",
    "        print(\" \"*i, end=\"\")\n",
    "        print(\"*\", end=\"\")\n",
    "        print(\" \"*i, end=\"\")\n",
    "        print(\"*\", end=\"\")\n",
    "        print(\" \"*((n-5)//2-i), end=\"\")\n",
    "        print(\"*\")\n",
    "    print(\"*\"*n)\n",
    "\n",
    "# AFTER REDUCING Don't worry if you don't understand what i just did. First just try to understand the above logic.\n",
    "# The below one is same as above, i just concatenated all the strings in one line.\n",
    "\n",
    "# n = int(input())\n",
    "# if n == 1: \n",
    "#     print(\"*\")\n",
    "# else: \n",
    "#     print(\"*\"*n)\n",
    "#     for i in range((n-3)//2): \n",
    "#         print(\"*\" + \" \"*i + \"*\" + (\" \"*((n-5)//2-i)+\"*\")*2 + \" \"*i + \"*\")\n",
    "#     print(\"*\"*n)\n",
    "#     for i in range((n-3)//2): \n",
    "#         print(\"*\" + \" \"*((n-5)//2 - i) + \"*\" +(\" \"*i + \"*\")*2 + \" \"*((n-5)//2-i) + \"*\")\n",
    "\n",
    "#     print(\"*\"*n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PPA 5**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "1 2 3\n",
      "5 6 29\n",
      "6 9 45\n",
      "7 15 76\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "for i in range(1, n): \n",
    "    for j in range(1, n): \n",
    "        for l in range(1, n): \n",
    "            if i == j or i == l or j == l: \n",
    "                continue\n",
    "            if i**4 + j**3 == l**2: \n",
    "                print(i, j, l)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PPA 6**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aeiou\n",
      "this is python program\n",
      "ths s pythn prgrm"
     ]
    }
   ],
   "source": [
    "a = input() \n",
    "b = input()\n",
    "\n",
    "output = \"\"; \n",
    "for i in b: \n",
    "    if not(i in a): \n",
    "        output += i\n",
    "    \n",
    "print(output, end=\"\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Activity Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 1\n",
    "Write a code using a while loop that adds all odd numbers from 1 to 100 (inclusive)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 2\n",
    "Write a program using a loop to print the first 10 even numbers in reverse order.. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Problem 3\n",
    "Write a program to accept the positive integer n from the user and print the average of all number's factorial from 1 to n ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 4\n",
    "Write a program to accept the positive integer n from the user and print counting of numbers which are not prime from 1 to n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 5\n",
    "Write a program to accept the string s from the user and print all alphabets in one line separated by , before first occurrence of vowels ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 6\n",
    "Write a program to accept the two positive integers start and stop where 0< start<stop<=100 print all numbers from start to stop both inclusive with following constraints.\n",
    "+ If the number is divisible by 3 print Divisible by 3 at the place of number.\n",
    "+ If the number is divisible by 5 print Divisible by 5 at the place of number.\n",
    "+ If the number is divisible by 10 print Divisible by 10 at the place of number.\n",
    "+ If the number is divisible by any of two from 3 ,5 and 10 , print nothing, just skip.\n",
    "+ If the number is divisible by all ( 3 , 5 and 10) , stop printing the number.\n",
    "+ If the number is not divisible by any of ( 3 , 5 and 10) , just print the number as it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 7\n",
    "Accept the positive integer n and display the cube of the number up to a given integer n in the following pattern using formatted string.\n",
    "<pre>\n",
    "<b>Input: </b>\n",
    "6\n",
    "<b>Output: </b>\n",
    "Current Number is : 1 and the cube is 1\n",
    "Current Number is : 2 and the cube is 8\n",
    "Current Number is : 3 and the cube is 27\n",
    "Current Number is : 4 and the cube is 64\n",
    "Current Number is : 5 and the cube is 125\n",
    "Current Number is : 6 and the cube is 216\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 9\n",
    "Write a code to accept the positive integer n from user and print average of 1 + 11 +111 + 1111 + ..n terms.\n",
    "<pre>\n",
    "<b>Input: </b>\n",
    "6\n",
    "<b>Output: </b>\n",
    "20576.0\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 11\n",
    "Write a code to accept positive integer n from user(n<10) and print following pattern.\n",
    "<pre>\n",
    "<b>Input: </b>\n",
    "5\n",
    "<b>Output: </b>\n",
    "5 4 3 2 1 2 3 4 5 \n",
    "  4 3 2 1 2 3 4 \n",
    "    3 2 1 2 3 \n",
    "      2 1 2 \n",
    "        1 \n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 12\n",
    "Write a code to accept the string of length 10 from the user and print True if string has any character occurring 5 times consecutively in it, otherwise print False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 13\n",
    "Write a code to accept the positive integer n from the user and print the following pattern.\n",
    "<pre>\n",
    "<b>Input: </b>\n",
    "5\n",
    "<b>Output: </b>\n",
    "1 \n",
    "1 2 \n",
    "1 2 3 \n",
    "1 2 3 4 \n",
    "1 2 3 4 5 \n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 14\n",
    "Write a code to accept a string as input and reverse it using loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 15\n",
    "Write a code to accept a string as input and determine if it is a palindrome or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 16\n",
    "Write a code to accept the name of a person as input and print the initials as output. Assume that the name will be of this form: \\<first name\\> \\<last name\\> . Also assume that the first name and last name will be a single word, and there will be exactly one space between the two names. For example, if the input is Rohit Sharma, the output should be RS.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 17\n",
    "Write a code for the following sequence:<br/>\n",
    "```|0||0|||0|```\n",
    "\n",
    "This sequence should be understood as follows: || represents an empty box. |0| represents a box that has an egg in it. These boxes are placed side by side so that the right wall of a box overlaps with the left wall of the box immediately to its right. For any arbitrary sequence given as input, your task is to find:\n",
    "+ total number of boxes\n",
    "+ number of empty boxes\n",
    "+ number of boxes that have eggs in them\n",
    "\n",
    "In the sequence given above, there are six boxes. Three are empty and the other three are non-empty\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 18\n",
    "You are given the results of a sequence of matches played by India in ODIs. A win is represented by 'W' and a loss is represented by 'L'. A winning streak is a string of consecutive wins. For example, if India has played five matches with the following results - 'WLWWWL' - then it has a three-match streak. Write a code to accept the result-sequence as input and find the longest streak in it.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 19\n",
    "Write a code to accept the sequence of positive integers in sorted order(either in non ascending order or non descending order) ending with -1 and at least two integers must be before -1 . In Output print the number of distinct elements in the sorted sequence before -1.\n",
    "<br/>\n",
    "**Test Case 1**\n",
    "<pre>\n",
    "<b>Input: </b>\n",
    "1\n",
    "2\n",
    "-1\n",
    "<b>Output: </b>\n",
    "2\n",
    "</pre>\n",
    "**Test Case 2**\n",
    "<pre>\n",
    "<b>Input: </b>\n",
    "7\n",
    "6\n",
    "6\n",
    "5\n",
    "5\n",
    "5\n",
    "-1\n",
    "<b>Output: </b>\n",
    "3\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 20\n",
    "Write a code to accept the sequence of positive integers ending with -1 and at least two distinct integers must be before -1.\n",
    "\n",
    "**In Output:**\n",
    "+ Print asc if sequence before -1 is sorted in ascending order or non descending order.\n",
    "+ Print desc if sequence before -1 is sorted in descending order or non ascending order.\n",
    "+ Print False if sequence before -1 is not sorted in any order.\n",
    "**Test Case 1**\n",
    "<pre>\n",
    "<b>Input: </b>\n",
    "1\n",
    "2\n",
    "2\n",
    "3\n",
    "3\n",
    "4\n",
    "-1\n",
    "<b>Output: </b>\n",
    "asc\n",
    "</pre>\n",
    "**Test Case 2**\n",
    "<pre>\n",
    "<b>Input: </b>\n",
    "7\n",
    "6\n",
    "6\n",
    "5\n",
    "5\n",
    "5\n",
    "-1\n",
    "<b>Output: </b>\n",
    "desc\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 21\n",
    "Write a program to print the product of the digits of a number entered by the user. Numbers can be either positive or negative.\n",
    "\n",
    "\n",
    "| Input | Output | \n",
    "| ----- | -----  |\n",
    "| 12345 | 120 | \n",
    "| 999 | 729 | \n",
    "| 1000 | 0 | \n",
    "| -12345 | 120 | \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 23\n",
    "Write a program to find the highest common factor (HCF) of two numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 25\n",
    "Write a program to find the sum of the below series.\n",
    "\n",
    "$1+ x^2 + x^3 + ....+ x^n $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### PROBLEM 26\n",
    "Write a program for the below scenario: <br/>\n",
    "The sum of a harmonic series approaches infinity when the number of terms increases.\n",
    "\n",
    "\n",
    "$1 + \\frac{1}{2} + \\frac{1}{3} + \\frac{1}{4}....$\n",
    "\n",
    "How many terms are required to reach the value near to 10. Consider the value for tolerance = 0.05\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 27\n",
    "Write a program for the harmonic mean of first n numbers. Accept n as an input from the user. Round off the answer to 2 decimal numbers.\n",
    "For example , the harmonic mean for the first 5 numbers can be written as.\n",
    "\n",
    "Harmonic Mean = $\\frac{5}{\\frac{1}{1} + \\frac{1}{2} +  \\frac{1}{3} +  \\frac{1}{4} + \\frac{1}{5}}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 28\n",
    "Write a program to number guessing games using loops. The program arbitrarily choses a number in the range 1 to 100 (inclusive) and asks the user to enter a guessed number. The program repeatedly asks the user to guess the number 5 times. For each guess, the program\n",
    "says TOO HIGH or TOO LOW or GOOD based on the below table.\n",
    "\n",
    "| DIFFERENCE | OUTPUT |\n",
    "| -- | --  | \n",
    "|guess numeber - actual number > 10 | TOO_HIGH | \n",
    "| actual number - guess number > 10 | TOO_LOW | \n",
    "| (actual number - guess number < 10) or (guess numeber - actual number < 10) | GOOD | \n",
    "| actual number - guess number = 0 | EXCELLENT |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 28\n",
    "Two numbers n1 and n2 are said to be the same if they have an equal number of digits in them. Write a program to check whether n1 and n2 are the same. n1 and n2 are positive integers entered by the user without converting the number to string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 31\n",
    "Write a program to print the Fibonacci series of n terms where n is always greater than or\n",
    "equal to 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 32\n",
    "Two numbers n1 and n2 are said to be same if they have equal number of digits in them.\n",
    "Write a program to check whether n1 and n2 are same. n1 and n2 are positive integers\n",
    "entered by the user without converting the number to string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 33\n",
    "Write a program to print the first and last digits of a number without converting it to string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SOLUTIONS \n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2496\n"
     ]
    }
   ],
   "source": [
    "counter = 1\n",
    "sum = 0\n",
    "while i <= 99: \n",
    "    sum += i\n",
    "    i += 2\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 2**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "18\n",
      "16\n",
      "14\n",
      "12\n",
      "10\n",
      "8\n",
      "6\n",
      "4\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(20, 1, -2): \n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 3**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8.25\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "sum = 0\n",
    "factorial = 1\n",
    "for i in range(1, n+1): \n",
    "    factorial *= i\n",
    "    sum += factorial \n",
    "print(sum/n)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 4**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "if n == 0: \n",
    "    print(0)\n",
    "else: \n",
    "    counting = 1\n",
    "    for i in range(2, n+1): \n",
    "        flag = True\n",
    "        for j in range(2, i): \n",
    "            if i%j == 0: \n",
    "                flag = False\n",
    "                break; \n",
    "        if not(flag): \n",
    "            counting += 1\n",
    "    print(counting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 5**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xyzzafdjklj\n",
      "x,y,z,z,"
     ]
    }
   ],
   "source": [
    "inp = input()\n",
    "vowels = \"aeiou\"\n",
    "vowels = vowels + vowels.upper()\n",
    "for i in inp: \n",
    "    if i in vowels: \n",
    "        break\n",
    "    print(i, end=\",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 6**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "20\n",
      "1\n",
      "2\n",
      "Divisible by 3\n",
      "4\n",
      "Divisible by 5\n",
      "Divisible by 3\n",
      "7\n",
      "8\n",
      "Divisible by 3\n",
      "11\n",
      "Divisible by 3\n",
      "13\n",
      "14\n",
      "16\n",
      "17\n",
      "Divisible by 3\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "start, stop = int(input()), int(input())\n",
    "for i in range(start, stop+1): \n",
    "    divisibleByThree = i%3 == 0\n",
    "    divisibleByFive = i%5 == 0\n",
    "    divisibleByTen = i%10 == 0\n",
    "    if  divisibleByThree and divisibleByFive and divisibleByTen: \n",
    "        break\n",
    "    elif (divisibleByThree and divisibleByFive) or (divisibleByThree and divisibleByTen) or (divisibleByFive and divisibleByTen) : \n",
    "        continue\n",
    "    elif divisibleByThree: \n",
    "        print(\"Divisible by 3\")\n",
    "    elif divisibleByFive: \n",
    "        print(\"Divisible by 5\")\n",
    "    elif divisibleByTen: \n",
    "        print(\"Divisible by 10\")\n",
    "    else: \n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 7**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "Current Number is : 1 and the cube is 1\n",
      "Current Number is : 2 and the cube is 8\n",
      "Current Number is : 3 and the cube is 27\n",
      "Current Number is : 4 and the cube is 64\n",
      "Current Number is : 5 and the cube is 125\n",
      "Current Number is : 6 and the cube is 216\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "for i in range(1, n+1): \n",
    "    print(f'Current Number is : {i} and the cube is {i**3}') \n",
    "\n",
    "# You need latest python compiler to run this program \n",
    "# because f-strings are not supported in earlier versions of python i guess below python@3.6 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 9**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "20576.0\n",
      "20576.0\n",
      "20576.0\n"
     ]
    }
   ],
   "source": [
    "# Method 1\n",
    "n = int(input())\n",
    "sum = 0\n",
    "for i in range(1, n+1): \n",
    "    sum += int(\"1\"*i)\n",
    "print(sum/n)\n",
    "\n",
    "# Method 2\n",
    "currentTerm = 0\n",
    "sum = 0\n",
    "for i in range(0, n): \n",
    "    currentTerm = currentTerm*10 + 1 #\n",
    "    sum += currentTerm\n",
    "print(sum/n)\n",
    "\n",
    "# Method 3 \n",
    "# Using Sum of GP formula, we can calculate it. \n",
    "print((((10**(n+1) - 10)/81) - ((n)/9))/n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 10**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5 4 3 2 1 2 3 4 5 \n",
      "  4 3 2 1 2 3 4 \n",
      "    3 2 1 2 3 \n",
      "      2 1 2 \n",
      "        1 \n",
      "5 4 3 2 1 2 3 4 5 \n",
      "  4 3 2 1 2 3 4 \n",
      "    3 2 1 2 3 \n",
      "      2 1 2 \n",
      "        1 \n"
     ]
    }
   ],
   "source": [
    "#Using for loop\n",
    "n = int(input())\n",
    "for i in range(n): \n",
    "    print(\"  \"*i, end=\"\")\n",
    "    for j in range(n-i, 1, -1): \n",
    "        print(j, end=\" \")\n",
    "    for j in range(1, n-i+1):\n",
    "        print(j, end=\" \")\n",
    "    print()\n",
    "#Using while loop \n",
    "i = 0\n",
    "while i < n: \n",
    "    print(\"  \"*i, end=\"\")\n",
    "    j = n-i\n",
    "    while j > 1: \n",
    "        print(j, end=\" \")\n",
    "        j -= 1\n",
    "    while j <= n-i:\n",
    "        print(j, end=\" \")\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 12**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aksdfljlaksdjzzzzzzzzzzz\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "s = input()\n",
    "for i in range(0, len(s)-4): \n",
    "    if s[i]*5 == s[i:i+5]: \n",
    "        print(True)\n",
    "        break\n",
    "else: \n",
    "    print(False)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 13**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "\u001b[31;1mMethod 1 Output\u001b[0m\n",
      "1 \n",
      "1 2 \n",
      "1 2 3 \n",
      "1 2 3 4 \n",
      "1 2 3 4 5 \n",
      "\n",
      "\u001b[34;1mMethod 2 Output\u001b[0m\n",
      "1 \n",
      "1 2 \n",
      "1 2 3 \n",
      "1 2 3 4 \n",
      "1 2 3 4 5 \n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "#Using For Loop\n",
    "print(\"\\x1b[31;1mMethod 1 Output\\x1b[0m\")\n",
    "for i in range(1, n+1): \n",
    "    for j in range(1, i+1): \n",
    "        print(j, end=\" \")\n",
    "    print()\n",
    "# Using While Loop\n",
    "print(\"\\n\\x1b[34;1mMethod 2 Output\\x1b[0m\")\n",
    "i = 1\n",
    "while i <= n: \n",
    "    j = 1\n",
    "    while j <= i: \n",
    "        print(j, end=\" \")\n",
    "        j+= 1\n",
    "    i += 1\n",
    "    print()\n",
    "#If you are curious how the output came red, blue and bold, then Google About \"Escape Codes.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 14**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abckjdf\n",
      "fdjkcba\n",
      "fdjkcba\n"
     ]
    }
   ],
   "source": [
    "string = input()\n",
    "reverse = ''\n",
    "# Using For Loop\n",
    "for char in string: \n",
    "    reverse = char + reverse\n",
    "print(reverse)\n",
    "# Using while loop\n",
    "i = 0\n",
    "reverse = ''\n",
    "while i < len(string): \n",
    "    reverse = string[i] + reverse\n",
    "    i+=1\n",
    "print(reverse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 15**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abbbbbbbbbbba\n",
      "Yes,string is palindrome\n",
      "Yes,string is palindrome\n"
     ]
    }
   ],
   "source": [
    "#Method 1 reverse and check\n",
    "string = input()\n",
    "reverse = string[::-1]\n",
    "if reverse == string: \n",
    "    print(\"Yes,string is palindrome\")\n",
    "else: \n",
    "    print(\"No,string is not palindrome\")\n",
    "    \n",
    "\n",
    "#Method 2 check first and last\n",
    "i, j = 0, len(string)-1\n",
    "flag = True #True means palindrome, False means not palindrome \n",
    "while i < j: \n",
    "    if string[i] != string[j]: \n",
    "        flag = False \n",
    "        break\n",
    "    j -=1 \n",
    "    i += 1\n",
    "if flag: \n",
    "    print(\"Yes,string is palindrome\")\n",
    "else: \n",
    "    print(\"No,string is not palindrome\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 16**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rohit Sharma\n",
      "RS\n"
     ]
    }
   ],
   "source": [
    "#Method 1 Using For Loop\n",
    "name = input()\n",
    "output = name[0]\n",
    "for index, i in enumerate(name): \n",
    "    if i == ' ' and index < len(name)-1: \n",
    "        output += name[index+1]\n",
    "        break\n",
    "print(output)\n",
    "\n",
    "#Method 2 Using While Loop\n",
    "#Try it yourself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 17**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|0||0|||0|\n",
      "The total number of box = 6\n",
      "The total number of empty box = 3\n",
      "Tumber of boxes that have eggs in them = 3\n"
     ]
    }
   ],
   "source": [
    "box = input()\n",
    "\n",
    "print(f\"The total number of box = {box.count('|')-1}\")\n",
    "print(f\"The total number of empty box = {box.count('|')-1-box.count('0')}\")\n",
    "print(f\"Tumber of boxes that have eggs in them = {box.count('0')}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 18**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WLWWLWWWWL\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "results = input().upper()\n",
    "max_streak = 0\n",
    "count = 0\n",
    "for i in results: \n",
    "    if i == \"W\": \n",
    "        count += 1\n",
    "    else: \n",
    "        count = 0\n",
    "    max_streak = max(max_streak, count)\n",
    "print(max_streak)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 19**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "6\n",
      "6\n",
      "5\n",
      "5\n",
      "5\n",
      "-1\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "prev = n = int(input())\n",
    "count = 1\n",
    "if n == -1: \n",
    "    count = 0\n",
    "while n != -1: \n",
    "    prev = n\n",
    "    n = int(input())\n",
    "    if n == -1: \n",
    "        break\n",
    "    if prev != n: \n",
    "        count += 1\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 20**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34;1m*************** Enter Inputs for Method 1 ***************\u001b[0m\n",
      "1\n",
      "2\n",
      "3\n",
      "-1\n",
      "asc\n",
      "\n",
      "\u001b[31;1m *************** Enter Inputs for Method 2  *************** \u001b[0m\n",
      "2\n",
      "3\n",
      "1\n",
      "-1\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "flag = -1 #0 for  ascending 1 for descending and -1 is for else part. \n",
    "print(f'\\x1b[34;1m{\"*\"*15} Enter Inputs for Method 1 {\"*\"*15}\\x1b[0m')\n",
    "prev = int(input())\n",
    "n = prev\n",
    "while n != -1: \n",
    "    prev = n\n",
    "    n = int(input())\n",
    "    if n == -1: \n",
    "        break\n",
    "    if prev == n: \n",
    "        continue\n",
    "    if prev < n: \n",
    "        if flag == 1: \n",
    "            flag = -1\n",
    "            break\n",
    "        flag = 0\n",
    "    elif prev > n: \n",
    "        if flag == 0: \n",
    "            flag = -1\n",
    "            break\n",
    "        flag = 1\n",
    "if flag == 0: \n",
    "    print(\"asc\")\n",
    "elif flag == 1: \n",
    "    print(\"desc\")\n",
    "else: \n",
    "    while n != -1: \n",
    "        n = int(input())\n",
    "    print(False)\n",
    "\n",
    "print(f\"\\n\\x1b[31;1m {'*'*15} Enter Inputs for Method 2  {'*'*15} \\x1b[0m\")\n",
    "# Method 2\n",
    "desc = asc = True\n",
    "prev = n = int(input())\n",
    "while n != -1: \n",
    "    prev = n\n",
    "    n = int(input())\n",
    "    if n == -1: \n",
    "        break\n",
    "    if prev < n: \n",
    "        desc = False\n",
    "    if prev > n: \n",
    "        asc = False\n",
    "if not(asc) and not(desc) or (asc and desc):#asc and desc both will be true if all n are same\n",
    "    print(False)\n",
    "elif asc: \n",
    "    print(\"asc\")\n",
    "else: \n",
    "    print(\"desc\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 21**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123456789\n",
      "362880\n",
      "123456789\n",
      "362880\n"
     ]
    }
   ],
   "source": [
    "n = abs(int(input())) # first convert number to int then to postive number\n",
    "product = 1\n",
    "if n == 0: \n",
    "    product = 0\n",
    "while n > 0: \n",
    "    product *= n%10\n",
    "    n //= 10\n",
    "print(product)\n",
    "\n",
    "#Method 2\n",
    "n = input()\n",
    "product = 1\n",
    "if int(n) == 0: \n",
    "    product = 0\n",
    "for i in n: \n",
    "    if i == '-': \n",
    "        continue\n",
    "    product *= int(i)\n",
    "print(product)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 23**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "a, b = int(input()), int(input())\n",
    "hcf = 1\n",
    "for i in range(2, min(a, b)+1): \n",
    "    if a%i == 0 and b%i == 0: \n",
    "        hcf = i\n",
    "print(hcf)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 25**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n",
      "37.0\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "x = float(input())\n",
    "sum = 1\n",
    "for i in range(2, n+1): \n",
    "    sum += x**i\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 26**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11764\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "sum = 0\n",
    "tolerance = 0.05\n",
    "i = 1\n",
    "while True: \n",
    "    sum += 1/i\n",
    "    count += 1\n",
    "    if abs(10 - sum) < tolerance: \n",
    "        break\n",
    "    i += 1\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 27**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "2.19\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "denominator_sum = 0\n",
    "for i in range(1, n+1): \n",
    "    denominator_sum += 1/i\n",
    "print(round(n/denominator_sum, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 28**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "TOO_LOW\n",
      "25\n",
      "TOO_LOW\n",
      "44\n",
      "TOO_LOW\n",
      "77\n",
      "TOO_HIGH\n",
      "58\n",
      "GOOD\n",
      "Actual Number was: 62\n"
     ]
    }
   ],
   "source": [
    "import random \n",
    "n = random.randint(1, 101)\n",
    "for i in range(1, 6): \n",
    "    user_input = int(input())\n",
    "    if n - user_input == 0: \n",
    "        print(\"EXCELLENT\")\n",
    "    elif abs(user_input-n) < 10: \n",
    "        print(\"GOOD\")\n",
    "    elif user_input-n > 10: \n",
    "        print(\"TOO_HIGH\")\n",
    "    else: \n",
    "        print(\"TOO_LOW\")\n",
    "print(f'Actual Number was: {n}')\n",
    "#     if user_input - n > 10: \n",
    "#         print(\"TOO_HIGH\")\n",
    "#     elif n - user_input  > 10: \n",
    "#         print(\"TOO_LOW\")\n",
    "#     elif (user_input - n < 10) or (n - user_input  < 10): \n",
    "#         print(\"GOOD\")\n",
    "#     elif n - user_input == 0: \n",
    "#         print(\"EXCELLENT\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 31**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "0 1 1 2 3 5 8 13 21 34 "
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "prev, current = 0, 1\n",
    "print(prev, current, end= \" \")\n",
    "for i in range(3, n+1): \n",
    "#     prev, current = current, prev+current\n",
    "    temp = prev\n",
    "    prev = current\n",
    "    current = current + temp\n",
    "    print(current, end = \" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 32**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123\n",
      "1234\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a, b = int(input()), int(input())\n",
    "a_digits, b_digits = 0, 0\n",
    "while a > 0: \n",
    "    a_digits += 1\n",
    "    a //= 10\n",
    "while b > 0: \n",
    "    b_digits += 1\n",
    "    b //= 10\n",
    "if a_digits == b_digits: \n",
    "    print(True)\n",
    "else: \n",
    "    print(False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 33**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-129378\n",
      "first digit: 8\n",
      "last digit: 1\n"
     ]
    }
   ],
   "source": [
    "num = abs(int(input()))\n",
    "print(f'first digit: {num%10}')\n",
    "if num//10 ==0: \n",
    "    print(\"please enter 2 digit number.\")\n",
    "else: \n",
    "    last_digit = 0\n",
    "    while num > 0: \n",
    "        last_digit = num%10\n",
    "        num //= 10\n",
    "    print(f'last digit: {last_digit}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}