Python Practice Problems Basics (1-20).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "83838ce7",
   "metadata": {},
   "source": [
    "# Python Practice Problems Basics (1-20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45bdd77d",
   "metadata": {},
   "source": [
    "#### 1. Write a Python program to print the following string in a specific format"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ac3e9c66",
   "metadata": {},
   "source": [
    "Sample String : \n",
    "\"Twinkle, twinkle, little star, How I wonder what you are! Up above the world so high, Like a diamond in the sky. Twinkle, twinkle, little star, How I wonder what you are\" \n",
    "\n",
    "Output :\n",
    "Twinkle, twinkle, little star,\n",
    "\tHow I wonder what you are! \n",
    "\t\tUp above the world so high,   \t\t\n",
    "\t\tLike a diamond in the sky. \n",
    "Twinkle, twinkle, little star, \n",
    "\tHow I wonder what you are"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f963c61a",
   "metadata": {},
   "source": [
    "**Approach:** Use of **new line character(\\n)** and **tab space(\\t)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "581fdc2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Twinkle, twinkle, little star, \n",
      "\tHow I wonder what you are! \n",
      "\t\tUp above the world so high, \n",
      "\t\tLike a diamond in the sky. \n",
      "Twinkle, twinkle, little star, \n",
      "\tHow I wonder what you are!\n"
     ]
    }
   ],
   "source": [
    "print(\"Twinkle, twinkle, little star, \\n\\tHow I wonder what you are! \\n\\t\\tUp above the world so high, \\n\\t\\tLike a diamond in the sky. \\nTwinkle, twinkle, little star, \\n\\tHow I wonder what you are!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "072d2e12",
   "metadata": {},
   "source": [
    "The **print statement (Python 2.6)** has been **replaced with** a **print() function**, with keyword arguments to replace most of the special syntax of the old print statement .\n",
    "\n",
    "- The print() function doesn’t support the “softspace” feature of the old print statement. For example, in Python 2.x, print \"A\\n\", \"B\" would write \"A\\nB\\n\"; but in Python 3.0, print(\"A\\n\", \"B\") writes \"A\\n B\\n\".\n",
    "\n",
    "- When using the 2 to 3 source-to-source conversion tool, all print statements are automatically converted to print() function calls, so this is mostly a non-issue for larger projects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c97456ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A B\n"
     ]
    }
   ],
   "source": [
    "print(\"A\", \"B\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28eb9a55",
   "metadata": {},
   "source": [
    "In this case, there is a comma between the two string arguments \"A\\n\" and \"B\". This comma separates the two arguments and instructs print function to print them with a space in between."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "aaf591e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      " B\n"
     ]
    }
   ],
   "source": [
    "print(\"A\\n\", \"B\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "642e86ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "B\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"A\\nB\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "531c680e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      " B\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"A\\n B\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a17f991f",
   "metadata": {},
   "source": [
    "#### 2. Write a Python program to find out what version of Python you are using"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e1169c1",
   "metadata": {},
   "source": [
    "A string containing the version number of the Python interpreter plus additional information on the build number and compiler used. This string is displayed when the interactive interpreter is started. \n",
    "\n",
    "**Version info:**\n",
    "\n",
    "A tuple containing the five components of the version number: **major, minor, micro, releaselevel and serial**. All values except releaselevel are integers; the release level is **'alpha', 'beta', 'candidate' or 'final'**. The version_info value corresponding to the Python version 2.0 is (2, 0, 0, 'final', 0). The components can also be accessed by name, so sys.version_info[0] is equivalent to sys.version_info.major and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "18b4a5c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python Version:\n",
      "3.9.13 (main, Aug 25 2022, 23:51:50) [MSC v.1916 64 bit (AMD64)]\n",
      "Version Info.:\n",
      "sys.version_info(major=3, minor=9, micro=13, releaselevel='final', serial=0)\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(\"Python Version:\")\n",
    "print (sys.version)\n",
    "print(\"Version Info.:\")\n",
    "print (sys.version_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "dd138e76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.9.13\n"
     ]
    }
   ],
   "source": [
    "import platform\n",
    "print(platform.python_version())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "12b4b922",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('3', '9', '13')\n"
     ]
    }
   ],
   "source": [
    "import platform\n",
    "print(platform.python_version_tuple())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdb97466",
   "metadata": {},
   "source": [
    "#### 3. Write a Python program to display the current date and time."
   ]
  },
  {
   "cell_type": "raw",
   "id": "ab55c8e2",
   "metadata": {},
   "source": [
    "Sample Output :\n",
    "Current date and time :\n",
    "2014-07-05 14:34:14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "dcdccf5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current date and time : \n",
      "2023-03-04 21:06:03\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "now = datetime.datetime.now()\n",
    "print (\"Current date and time : \")\n",
    "print (now.strftime(\"%Y-%m-%d %H:%M:%S\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7be0df67",
   "metadata": {},
   "source": [
    "#### 4. Write a Python program that calculates the area of a circle based on the radius entered by the user"
   ]
  },
  {
   "cell_type": "raw",
   "id": "b1180cea",
   "metadata": {},
   "source": [
    "Sample Output :\n",
    "r = 1.1\n",
    "Area = 3.8013271108436504"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "887639b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def area_circle():\n",
    "    radius=float(input(\"Input the radius of  circle : \"))\n",
    "    area = print(\"The area of the circle with radius \"+ str(radius)+\" is \" + str(3.14*radius**2))\n",
    "    return area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "fc50a98a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the radius of  circle : 5\n",
      "The area of the circle with radius 5.0 is 78.5\n"
     ]
    }
   ],
   "source": [
    "area_circle1= area_circle()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d99232e",
   "metadata": {},
   "source": [
    "#### 5. Write a Python program that accepts the user's first and last name and prints them in reverse order with a space between them."
   ]
  },
  {
   "cell_type": "raw",
   "id": "f4a97ee3",
   "metadata": {},
   "source": [
    "Sample Input:\n",
    "First Name: Manish\n",
    "Last Name:  Kumar\n",
    "\n",
    "Sample Output:\n",
    "Kumar Manish"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "569e0266",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input your First Name : Manish\n",
      "Input your Last Name : Kumar\n",
      "Kumar Manish\n"
     ]
    }
   ],
   "source": [
    "first_name = input(\"Input your First Name : \")\n",
    "last_name = input(\"Input your Last Name : \")\n",
    "print (last_name + \" \" + first_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dd7a613",
   "metadata": {},
   "source": [
    "#### 6. Write a Python program that accepts a sequence of comma-separated numbers from the user and generates a list and a tuple of those numbers."
   ]
  },
  {
   "cell_type": "raw",
   "id": "29a98974",
   "metadata": {},
   "source": [
    "Sample Input : \n",
    "3, 5, 7, 23\n",
    "\n",
    "Sample Output :\n",
    "List : ['3', ' 5', ' 7', ' 23']\n",
    "Tuple : ('3', ' 5', ' 7', ' 23')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "1e5b9c36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input comma separated numbers : 3,5,7,23\n",
      "List :  ['3', '5', '7', '23']\n",
      "Tupple :  ('3', '5', '7', '23')\n"
     ]
    }
   ],
   "source": [
    "sample_input = input(\"Input comma separated numbers : \")\n",
    "sample_split = sample_input.split(\",\")\n",
    "print(\"List : \", list(sample_split))\n",
    "print(\"Tupple : \", tuple(sample_split))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c43f2121",
   "metadata": {},
   "source": [
    "#### 7. Write a Python program that accepts a filename from the user and prints the extension of the file. "
   ]
  },
  {
   "cell_type": "raw",
   "id": "494f6081",
   "metadata": {},
   "source": [
    "Sample filename : \n",
    "abc.java\n",
    "\n",
    "Sample Output : \n",
    "java"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "3a3183c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the Filename: abc.java\n",
      "The extension of the file is : 'java'\n"
     ]
    }
   ],
   "source": [
    "file_name = input(\"Input the Filename: \")\n",
    "file_extns = file_name.split(\".\")\n",
    "print(\"The extension of the file is : \" +repr(file_extns[-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1b0c5a1",
   "metadata": {},
   "source": [
    "repr() is a built-in Python function that returns a string representation of an object. The string returned by repr() is usually a valid Python expression that can be used to recreate the object. In other words, repr() is used to generate a string that describes the object in a way that is useful for debugging, logging, or other programming tasks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ee4a3fa8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the Filename: abc.java\n",
      "The extension of the file is : java\n"
     ]
    }
   ],
   "source": [
    "file_name = input(\"Input the Filename: \")\n",
    "file_extns = file_name.split(\".\")[-1]\n",
    "print(f\"The extension of the file is : {file_extns}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8078c361",
   "metadata": {},
   "source": [
    "#### 8. Write a Python program to display the first and last colors from the following list."
   ]
  },
  {
   "cell_type": "raw",
   "id": "1505a304",
   "metadata": {},
   "source": [
    "color_list = [\"Red\",\"Green\",\"White\" ,\"Black\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "eaefa86c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Red', 'Green', 'White', 'Black']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "color_list = [\"Red\", \"Green\", \"White\", \"Black\"]\n",
    "color_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "dbe5636f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Color :  Red \n",
      "Last Color :  Black\n"
     ]
    }
   ],
   "source": [
    "print(\"First Color : \", color_list[0], \"\\nLast Color : \", color_list[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e287b67c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Red Black\n"
     ]
    }
   ],
   "source": [
    "color_list = [\"Red\",\"Green\",\"White\" ,\"Black\"]\n",
    "print( \"%s %s\"%(color_list[0],color_list[-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "91be5ee3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Red Black\n"
     ]
    }
   ],
   "source": [
    "print(f\"{color_list[0]} {color_list[-1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ecbb441",
   "metadata": {},
   "source": [
    "%s, f, {} are here used as placeholders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64443412",
   "metadata": {},
   "source": [
    "#### 9. Write a Python program to display the examination schedule. (extract the date from exam_st_date)."
   ]
  },
  {
   "cell_type": "raw",
   "id": "450b67bf",
   "metadata": {},
   "source": [
    "exam_st_date = (11, 12, 2014)\n",
    "\n",
    "Sample Output : \n",
    "The examination will start from : 11 / 12 / 2014"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cb8dc7ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(11, 12, 2014)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exam_st_date = (11,12,2014)\n",
    "exam_st_date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6693c163",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The examination will start from : 11 / 12 / 2014\n"
     ]
    }
   ],
   "source": [
    "exam_st_date = (11,12,2014)\n",
    "print( \"The examination will start from : %i / %i / %i\"%exam_st_date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "05ff4487",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The examination will start from :11/12/2014\n"
     ]
    }
   ],
   "source": [
    "exam_st_date = (11, 12, 2014)\n",
    "print(f\"The examination will start from :{exam_st_date[0]}/{exam_st_date[1]}/{exam_st_date[2]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47fbdb20",
   "metadata": {},
   "source": [
    "The % operator in python for strings is used for something called string substitution. String and Unicode objects have one unique built-in operation: the % operator (modulo).\n",
    "\n",
    "https://stackoverflow.com/questions/20450531/python-operator-in-print-statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d006e65c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The examination will start from : 11/13/2021\n"
     ]
    }
   ],
   "source": [
    "Exam_data=(11,13,2021)\n",
    "print(\"The examination will start from :\",Exam_data[0],end=\"/\")\n",
    "print(Exam_data[1],end=\"/\")\n",
    "print(Exam_data[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec7bd50b",
   "metadata": {},
   "source": [
    "#### 10. Write a Python program that accepts an integer (n) and computes the value of n+nn+nnn. "
   ]
  },
  {
   "cell_type": "raw",
   "id": "509a7791",
   "metadata": {},
   "source": [
    "Sample value of n is 5\n",
    "Expected Result : 615"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a87b6ca1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number : 5\n",
      "615\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter a number : \"))\n",
    "n1 = n\n",
    "n2 = n*11\n",
    "n3 = n*111\n",
    "print(n1+n2+n3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2db1b7e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number : 5\n",
      "615\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter a number : \"))\n",
    "n1 = str(n)\n",
    "n2 = str(n) + str(n)\n",
    "n3 = str(n) + str(n) + str(n)\n",
    "print(int(n1) + int(n2) + int(n3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0ef37d67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input an integer : 5\n",
      "615\n"
     ]
    }
   ],
   "source": [
    "a = int(input(\"Input an integer : \"))\n",
    "n1 = int( \"%s\" % a )\n",
    "n2 = int( \"%s%s\" % (a,a) )\n",
    "n3 = int( \"%s%s%s\" % (a,a,a) )\n",
    "print (n1+n2+n3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7499ee04",
   "metadata": {},
   "source": [
    "#### 11. Write a Python program to print the documents (syntax, description etc.) of Python built-in function(s). "
   ]
  },
  {
   "cell_type": "raw",
   "id": "af063b10",
   "metadata": {},
   "source": [
    "Sample function : abs()\n",
    "Expected Result :\n",
    "abs(number) -> number\n",
    "Return the absolute value of the argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1a6ca3ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Return the absolute value of the argument.\n"
     ]
    }
   ],
   "source": [
    "print(abs.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "ce1b5043",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function abs in module builtins:\n",
      "\n",
      "abs(x, /)\n",
      "    Return the absolute value of the argument.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(abs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "9227e90f",
   "metadata": {},
   "outputs": [],
   "source": [
    "abs?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19a21d85",
   "metadata": {},
   "source": [
    "#### 12. Write a Python program that prints the calendar for a given month and year.\n",
    "Note : Use 'calendar' module. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "fe941646",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the year : 2023\n",
      "Input the month : 3\n",
      "     March 2023\n",
      "Mo Tu We Th Fr Sa Su\n",
      "       1  2  3  4  5\n",
      " 6  7  8  9 10 11 12\n",
      "13 14 15 16 17 18 19\n",
      "20 21 22 23 24 25 26\n",
      "27 28 29 30 31\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import calendar\n",
    "y = int(input(\"Input the year : \"))\n",
    "m = int(input(\"Input the month : \"))\n",
    "print(calendar.month(y, m))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae29eb9e",
   "metadata": {},
   "source": [
    "#### 13. Write a Python program to print the following 'here document'."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8230591a",
   "metadata": {},
   "source": [
    "A here document (or \"heredoc\") is a way of specifying a text block, preserving the line breaks, indents and other whitespace within the text."
   ]
  },
  {
   "cell_type": "raw",
   "id": "ebac2b80",
   "metadata": {},
   "source": [
    "Sample string :\n",
    "a string that you \"don't\" have to escape\n",
    "This\n",
    "is a ....... multi-line\n",
    "heredoc string --------> example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "0fdd57af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "a string that you \"don't\" have to escape\n",
      "This\n",
      "is a ....... multi-line\n",
      "heredoc string --------> example\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print('''\n",
    "a string that you \"don't\" have to escape\n",
    "This\n",
    "is a ....... multi-line\n",
    "heredoc string --------> example\n",
    "''')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45fdc1b8",
   "metadata": {},
   "source": [
    "#### 14. Write a Python program to calculate the number of days between two dates."
   ]
  },
  {
   "cell_type": "raw",
   "id": "90f7ba06",
   "metadata": {},
   "source": [
    "Sample dates : (2014, 7, 2), (2014, 7, 11)\n",
    "Expected output : 9 days "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "8fc5f132",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 days, 0:00:00\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "from datetime import date\n",
    "start_date = date(2014, 7, 2)\n",
    "end_date = date(2014, 7, 11)\n",
    "diff_days = end_date - start_date\n",
    "print(diff_days)\n",
    "print(diff_days.days)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "4595c9a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Write the start date in the next format (YYYY/MM/DD): 2015/02/23\n",
      "Write the end date in the next format (YYYY/MM/DD): 2023/03/20\n",
      "['2015', '02', '23'] ['2023', '03', '20']\n",
      "2947 days, 0:00:00\n",
      "2947\n"
     ]
    }
   ],
   "source": [
    "from datetime import date\n",
    "date1 = input('Write the start date in the next format (YYYY/MM/DD): ').split('/')\n",
    "date2 = input('Write the end date in the next format (YYYY/MM/DD): ').split('/')\n",
    "print(date1,date2)\n",
    "start_date = date(int(date1[0]),int(date1[1]),int(date1[2]))\n",
    "end_date = date(int(date2[0]),int(date2[1]),int(date2[2]))\n",
    "diff_days = end_date - start_date\n",
    "print(diff_days)\n",
    "print(diff_days.days)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eeeda4e",
   "metadata": {},
   "source": [
    "#### 15. Write a Python program to get the volume of a sphere with radius six."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "5a8e2efb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def volume_sphere():\n",
    "    radius = float(input(\"Enter the radius : \"))\n",
    "    volume = (4/3)*3.14*radius**3\n",
    "    return print(\"The Volume of sphere : \", volume)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "9c734481",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the radius : 5\n",
      "The Volume of sphere :  523.3333333333334\n"
     ]
    }
   ],
   "source": [
    "vol_sphere  = volume_sphere()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3731144",
   "metadata": {},
   "source": [
    "#### 16. Write a Python program to calculate the difference between a given number and 17. If the number is greater than 17, return twice the absolute difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "ae33654b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the number : 20\n",
      "Difference between number and 17 is :  3\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "input_number = int(input(\"Input the number : \"))\n",
    "diff = input_number - 17\n",
    "print(\"Difference between number and 17 is : \", diff)\n",
    "if input_number>17:\n",
    "    print(2*abs(diff))\n",
    "else:\n",
    "    print(\"Input number is less than 17\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d392382",
   "metadata": {},
   "source": [
    "#### 17. Write a Python program to test whether a number is within 100 of 1000 or 2000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "4d16946f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the number : 1900\n",
      "Within 100 of 2000\n"
     ]
    }
   ],
   "source": [
    "input_number = int(input(\"Input the number : \"))\n",
    "if  abs(1000-input_number)<=100:\n",
    "    print(\"Within 100 of 1000\")\n",
    "elif abs(2000-input_number)<=100:\n",
    "    print(\"Within 100 of 2000\")\n",
    "else:\n",
    "    print(\"Not in range\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f1ca02c",
   "metadata": {},
   "source": [
    "#### 18. Write a Python program to calculate the sum of three given numbers. If the values are equal, return three times their sum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "2ab67e43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first number : 5\n",
      "Enter the second the number : 5\n",
      "Enter the third number : 5\n",
      "Since the all numbers are equal then output is thrice the sum :  45\n"
     ]
    }
   ],
   "source": [
    "input_number1=int(input(\"Enter the first number : \"))\n",
    "input_number2=int(input(\"Enter the second the number : \"))\n",
    "input_number3=int(input(\"Enter the third number : \"))\n",
    "sum_numbers =input_number1+input_number2+input_number3\n",
    "if input_number1==input_number2==input_number3:\n",
    "    print(\"Since the all numbers are equal then output is thrice the sum : \", 3*sum_numbers)\n",
    "else:\n",
    "    print(sum_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d22fdc1",
   "metadata": {},
   "source": [
    "#### 19. Write a Python program to get a newly-generated string from a given string where \"Is\" has been added to the front. Return the string unchanged if the given string already begins with \"Is\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "7bfe366e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the text : Is India great\n",
      "Is India great\n"
     ]
    }
   ],
   "source": [
    "input_string = input(\"Enter the text : \")\n",
    "if len(input_string)>=2 and input_string[:2]==\"Is\":\n",
    "    print(input_string)\n",
    "else:\n",
    "    print(\"Is \" + input_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21daf179",
   "metadata": {},
   "source": [
    "#### 20. Write a Python program that returns a string that is n (non-negative integer) copies of a given string. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "f34bf2a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the text : India is great\n",
      "Enter the number of copies required(non-negative integer) : 5\n",
      "India is greatIndia is greatIndia is greatIndia is greatIndia is great\n"
     ]
    }
   ],
   "source": [
    "input_string=input(\"Enter the text : \")\n",
    "copies_required=int(input(\"Enter the number of copies required(non-negative integer) : \"))\n",
    "print(input_string*copies_required)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}