Python Basic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3sUjFmZ6RFuB"
   },
   "source": [
    "## **1. Get the Python version**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 102
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 2080,
     "status": "ok",
     "timestamp": 1575720532361,
     "user": {
      "displayName": "shashank shukla",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCLxPBdnT4JDxwflkTF4gEyaoX2n7-EJNCJ3bLdC_w=s64",
      "userId": "07121829256048994862"
     },
     "user_tz": -330
    },
    "id": "hdZCuIewQt22",
    "outputId": "a79dadd2-a938-497c-d1c8-de7162ca898f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python version\n",
      "3.6.9 (default, Nov  7 2019, 10:44:02) \n",
      "[GCC 8.3.0]\n",
      "Version info.\n",
      "sys.version_info(major=3, minor=6, micro=9, 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": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cwLZL-dyRwQ6"
   },
   "source": [
    "## **2. Display the current date and time**\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 992,
     "status": "ok",
     "timestamp": 1575721421079,
     "user": {
      "displayName": "shashank shukla",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCLxPBdnT4JDxwflkTF4gEyaoX2n7-EJNCJ3bLdC_w=s64",
      "userId": "07121829256048994862"
     },
     "user_tz": -330
    },
    "id": "nisizNEcR4Ag",
    "outputId": "7ea759e2-a3ad-478b-f7de-6da2da6bae50"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current date and time : \n",
      "2019-12-07 12:23:39\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",
   "metadata": {
    "colab_type": "text",
    "id": "9nEwuDmMUTPP"
   },
   "source": [
    "## **3. Input the radius of a circle and compute the area**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 9537,
     "status": "ok",
     "timestamp": 1575721954271,
     "user": {
      "displayName": "shashank shukla",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCLxPBdnT4JDxwflkTF4gEyaoX2n7-EJNCJ3bLdC_w=s64",
      "userId": "07121829256048994862"
     },
     "user_tz": -330
    },
    "id": "BqhhaLfTUT46",
    "outputId": "76d6341b-9180-496a-bed4-303dabb508b7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the radius of the circle : 3.4\n",
      "the are of the circle with radius 3.4 is: 36.316811075498\n"
     ]
    }
   ],
   "source": [
    "from math import pi\n",
    "r = float(input (\"Input the radius of the circle : \"))\n",
    "print (\"the are of the circle with radius \" +str(r) + \" is: \" + str(pi * r**2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AiYGrwKSWmzO"
   },
   "source": [
    "## **4. Print first and last name in reverse order with a space between them**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 16834,
     "status": "ok",
     "timestamp": 1575723414316,
     "user": {
      "displayName": "shashank shukla",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCLxPBdnT4JDxwflkTF4gEyaoX2n7-EJNCJ3bLdC_w=s64",
      "userId": "07121829256048994862"
     },
     "user_tz": -330
    },
    "id": "OG0Lfm-5XdLW",
    "outputId": "e4060078-507d-4a33-bb91-6d7cedc90ecc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input your First Name : shashank\n",
      "Input your Last Name : shukla\n",
      "Hello  shukla shashank\n"
     ]
    }
   ],
   "source": [
    "fname = input(\"Input your First Name : \")\n",
    "lname = input(\"Input your Last Name : \")\n",
    "print (\"Hello  \" + lname + \" \" + fname)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vK42QaQMb4W8"
   },
   "source": [
    "## **5. Generate a list and tuple with comma-separated numbers**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 15845,
     "status": "ok",
     "timestamp": 1575808907262,
     "user": {
      "displayName": "shashank shukla",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCLxPBdnT4JDxwflkTF4gEyaoX2n7-EJNCJ3bLdC_w=s64",
      "userId": "07121829256048994862"
     },
     "user_tz": -330
    },
    "id": "NsVJDzn7h8hq",
    "outputId": "148a2bff-b6df-4685-e8f4-ae2f574a6296"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input some comma seprated numbers : 1,2,5,4,6\n",
      "List :  ['1', '2', '5', '4', '6']\n",
      "Tuple :  ('1', '2', '5', '4', '6')\n"
     ]
    }
   ],
   "source": [
    "values = input(\"Input some comma seprated numbers : \")\n",
    "X = values.split(\",\")\n",
    "Y = tuple(X)\n",
    "print('List : ',X)\n",
    "print('Tuple : ',Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FAcPvJ7qiMWp"
   },
   "source": [
    "## **6. Input a filename and print the extension of that**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 24570,
     "status": "ok",
     "timestamp": 1575809620983,
     "user": {
      "displayName": "shashank shukla",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCLxPBdnT4JDxwflkTF4gEyaoX2n7-EJNCJ3bLdC_w=s64",
      "userId": "07121829256048994862"
     },
     "user_tz": -330
    },
    "id": "kNQEZoeFirGf",
    "outputId": "3aaa82bd-ec44-4030-f7c4-a7bc3f8abf8e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the Filename: Jack.sparrow\n",
      "The extension of the file is : 'sparrow'\n"
     ]
    }
   ],
   "source": [
    "filename = input(\"Input the Filename: \")\n",
    "f_extns = filename.split(\".\")\n",
    "print (\"The extension of the file is : \" + repr(f_extns[-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HKYrxIJSksbE"
   },
   "source": [
    "## **7. Display the first and last colors from a given list**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 4464,
     "status": "ok",
     "timestamp": 1575810038373,
     "user": {
      "displayName": "shashank shukla",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCLxPBdnT4JDxwflkTF4gEyaoX2n7-EJNCJ3bLdC_w=s64",
      "userId": "07121829256048994862"
     },
     "user_tz": -330
    },
    "id": "3NzkHleemDro",
    "outputId": "8e089c23-dfc2-4811-c838-bfc3674b3cb4"
   },
   "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": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "p3FNE9TapwRw"
   },
   "source": [
    "## **8. Display a sample examination schedule**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 3058,
     "status": "ok",
     "timestamp": 1575811207620,
     "user": {
      "displayName": "shashank shukla",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCLxPBdnT4JDxwflkTF4gEyaoX2n7-EJNCJ3bLdC_w=s64",
      "userId": "07121829256048994862"
     },
     "user_tz": -330
    },
    "id": "t-UPAkRqp_yY",
    "outputId": "51da5011-1b9b-424f-a526-4a557252e4b3"
   },
   "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": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WXgfg6RKqv_b"
   },
   "source": [
    "# **9. Input an integer (n) and computes the value of n+nn+nnn**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 10567,
     "status": "ok",
     "timestamp": 1575813125754,
     "user": {
      "displayName": "shashank shukla",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCLxPBdnT4JDxwflkTF4gEyaoX2n7-EJNCJ3bLdC_w=s64",
      "userId": "07121829256048994862"
     },
     "user_tz": -330
    },
    "id": "-yJiXeaRq_Em",
    "outputId": "bffe9f9e-4fc2-4d04-8087-e358373824f8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input an integer : 10\n",
      "102030\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",
   "metadata": {
    "colab_type": "text",
    "id": "oJNC-AxoyNwX"
   },
   "source": [
    "# **10. Print the calendar of a given month and year**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 27793,
     "status": "ok",
     "timestamp": 1575817571245,
     "user": {
      "displayName": "shashank shukla",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCLxPBdnT4JDxwflkTF4gEyaoX2n7-EJNCJ3bLdC_w=s64",
      "userId": "07121829256048994862"
     },
     "user_tz": -330
    },
    "id": "AUn4oZ9AycKi",
    "outputId": "021c382d-3e17-496a-959f-a4b3b81e6ec0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input the year : 2019\n",
      "input the month : 03\n",
      "     March 2019\n",
      "Mo Tu We Th Fr Sa Su\n",
      "             1  2  3\n",
      " 4  5  6  7  8  9 10\n",
      "11 12 13 14 15 16 17\n",
      "18 19 20 21 22 23 24\n",
      "25 26 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",
    "\n",
    "print(calendar.month(y, m))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **11. Print a specified document**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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",
   "metadata": {},
   "source": [
    "# **12. Calculate number of days between two dates**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10117\n"
     ]
    }
   ],
   "source": [
    "from datetime import date\n",
    "f_date = date(1992, 3, 30)\n",
    "l_date = date(2019, 12, 11)\n",
    "delta = l_date - f_date\n",
    "print(delta.days)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6613\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "date_format = (\"%m/%d/%Y\")\n",
    "a = datetime.strptime('8/18/2001', date_format)\n",
    "b = datetime.strptime('9/26/2019', date_format)\n",
    "delta = b - a\n",
    "print (delta.days)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-12-08\n",
      "365 days, 0:00:00\n"
     ]
    }
   ],
   "source": [
    "import datetime \n",
    "today = datetime.date.today() \n",
    "print(today)\n",
    "last_year = datetime.date(2018, 12, 8) \n",
    "print(today - last_year)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 13. Get the the volume of a sphere with radius 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The volume of the sphere is:  523.5987755982989\n"
     ]
    }
   ],
   "source": [
    "#The volume of the sphere is : V = 4/3 × π × r3 = π × d3/6\n",
    "\n",
    "pi = 3.1415926535897931\n",
    "r= 5.0\n",
    "V= 4.0/3.0*pi* r**3\n",
    "print('The volume of the sphere is: ',V)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 14. Get the difference between a given number and 15, if the number is greater than 15 return double the absolute difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def difference(n):\n",
    "    if n <= 15:\n",
    "        return 15 - n\n",
    "    else:\n",
    "        return (n - 15) * 2 \n",
    "\n",
    "print(difference(19))\n",
    "print(difference(11))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 15. Test whether a number is within 100 of 1000 or 2000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def near_thousand(n):\n",
    "      return ((abs(1000 - n) <= 100) or (abs(2000 - n) <= 100))\n",
    "print(near_thousand(1000))\n",
    "print(near_thousand(900))\n",
    "print(near_thousand(800))   \n",
    "print(near_thousand(2200))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 16. Calculate the sum of three given numbers, if the values are equal then return thrice of their sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "def sum_thrice(x,y,z):\n",
    "\n",
    "    sum = x + y + z\n",
    "    \n",
    "    if x == y == z:\n",
    "      sum = sum * 3\n",
    "    return sum\n",
    "\n",
    "print(sum_thrice(1, 2, 3))\n",
    "print(sum_thrice(3, 3, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 17. Get a new string from a given string where 'Is' has been added to the front. If the given string already begins with 'Is' then return the string unchanged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IsArray\n",
      "IsEmpty\n"
     ]
    }
   ],
   "source": [
    "def new_string(str):\n",
    "  if len(str) >= 2 and str[:2] == \"Is\":\n",
    "    return str\n",
    "  return \"Is\" + str\n",
    "\n",
    "print(new_string(\"Array\"))\n",
    "print(new_string(\"IsEmpty\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 18. Get a string which is n (non-negative integer) copies of a given string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcabc\n",
      ".py.py.py\n"
     ]
    }
   ],
   "source": [
    "def larger_string(str, n):\n",
    "   result = \"\"\n",
    "   for i in range(n):\n",
    "      result = result + str\n",
    "   return result\n",
    "\n",
    "print(larger_string('abc', 2))\n",
    "print(larger_string('.py', 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 19. Find whether a given number is even or odd, print out an appropriate message to the user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 21\n",
      "This is odd number\n"
     ]
    }
   ],
   "source": [
    "num = int(input(\"Enter a number: \"))\n",
    "mod = num%2\n",
    "\n",
    "if  mod > 0:\n",
    "    print(\"This is odd number\")\n",
    "else:\n",
    "    print(\"This is even number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 20. Count the number 4 in a given list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def list_count_4(nums):\n",
    "  count = 0  \n",
    "  for num in nums:\n",
    "    if num == 4:\n",
    "      count = count + 1\n",
    "\n",
    "  return count\n",
    "\n",
    "print(list_count_4([1, 4, 6, 7, 4]))\n",
    "print(list_count_4([1, 4, 6, 4, 7, 4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 21. n (non-negative integer) copies of the first 2 characters of a given string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abab\n",
      "ppp\n"
     ]
    }
   ],
   "source": [
    "def substring_copy(str, n):\n",
    "  flen = 2\n",
    "  if flen > len(str):\n",
    "      flen = len(str)\n",
    "  substr = str[:flen]\n",
    "  \n",
    "  result = \"\"\n",
    "  for i in range(n):\n",
    "    result = result + substr\n",
    "  return result\n",
    "\n",
    "print(substring_copy('abcdef', 2))\n",
    "print(substring_copy('p', 3));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 22. Test whether a passed letter is a vowel or not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def is_vowel(char):\n",
    "    all_vowels = 'aeiou'\n",
    "    return char in all_vowels\n",
    "\n",
    "print(is_vowel('c'))\n",
    "print(is_vowel('e'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 23.  Check whether a specified value is contained in a group of values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def is_group_member(group_data, n):\n",
    "    for value in group_data:\n",
    "        if n == value:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "print(is_group_member([1, 5, 8, 3], 3))\n",
    "print(is_group_member([5, 8, 3], -1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 24. Create a histogram from a given list of integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "**\n",
      "***\n",
      "******\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "def histogram( items ):\n",
    "    for n in items:\n",
    "        output = ''\n",
    "        times = n\n",
    "        while( times > 0 ):\n",
    "          output += '*'\n",
    "          times = times - 1\n",
    "        print(output)\n",
    "\n",
    "histogram([2, 3, 6, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 25. Concatenate all elements in a list into a string and return it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "112222\n"
     ]
    }
   ],
   "source": [
    "def concatenate_list_data(list):\n",
    "    result= ''\n",
    "    for element in list:\n",
    "        result += str(element)\n",
    "    return result\n",
    "\n",
    "print(concatenate_list_data([1,12,2,22]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 26. Print all even numbers from a given numbers list in the same order and stop the printing if any numbers that come after 237 in the sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "386\n",
      "462\n",
      "418\n",
      "344\n",
      "236\n",
      "566\n",
      "978\n",
      "328\n",
      "162\n",
      "758\n",
      "918\n",
      "412\n",
      "566\n",
      "826\n",
      "248\n",
      "866\n",
      "950\n"
     ]
    }
   ],
   "source": [
    "numbers = [    \n",
    "    386, 462, 47, 418, 907, 344, 236, 375, 823, 566, 597, 978, 328, 615, 953, 345, \n",
    "    399, 162, 758, 219, 918, 237, 412, 566, 826, 248, 866, 950, 626, 949, 687, 217, \n",
    "    815, 67, 104, 58, 512, 24, 892, 894, 767, 553, 81, 379, 843, 831, 445, 742, 717, \n",
    "    958,743, 527\n",
    "    ]\n",
    "\n",
    "for x in numbers:\n",
    "    if x == 950:\n",
    "        print(x)\n",
    "        break;\n",
    "    elif x % 2 == 0:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 27. Print out a set containing all the colors from a list which are not present in other list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a Python program to print out a set containing all the colors from color_list_1 which are not present in color_list_2.\n",
    "\n",
    "Test Data:\n",
    "color_list_1 = set([\"White\", \"Black\", \"Red\"])\n",
    "color_list_2 = set([\"Red\", \"Green\"])\n",
    "Expected Output :\n",
    "{'Black', 'White'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'White', 'Black'}\n"
     ]
    }
   ],
   "source": [
    "color_list_1 = set([\"White\", \"Black\", \"Red\"])\n",
    "color_list_2 = set([\"Red\", \"Green\"])\n",
    "\n",
    "print(color_list_1.difference(color_list_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 28. Accept the base and height of a triangle and compute the area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the base : 25\n",
      "Input the height : 30\n",
      "area =  375.0\n"
     ]
    }
   ],
   "source": [
    "b = int(input(\"Input the base : \"))\n",
    "h = int(input(\"Input the height : \"))\n",
    "\n",
    "area = b*h/2\n",
    "\n",
    "print(\"area = \", area)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input the height : 20\n",
      "input the area : 10\n",
      "b =  20.0\n"
     ]
    }
   ],
   "source": [
    "h = int(input(\"Input the height : \"))\n",
    "a = int(input(\"input the area : \"))\n",
    "\n",
    "area = b*h/2\n",
    "\n",
    "\n",
    "b = area*2/h\n",
    "\n",
    "print(\"b = \", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 29. Compute the greatest common divisor (GCD) of two positive integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Write a Python program to compute the greatest common divisor (GCD) of two positive integers.\n",
    "\n",
    "def gcd(x, y):\n",
    "    gcd = 1\n",
    "    \n",
    "    if x % y == 0:\n",
    "        return y\n",
    "    \n",
    "    for k in range(int(y / 2), 0, -1):\n",
    "        if x % k == 0 and y % k == 0:\n",
    "            gcd = k\n",
    "            break  \n",
    "    return gcd\n",
    "\n",
    "print(gcd(12, 17))\n",
    "print(gcd(4, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 30. Get the least common multiple (LCM) of two positive integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "255\n"
     ]
    }
   ],
   "source": [
    "# Write a Python program to get the least common multiple (LCM) of two positive integers.\n",
    "\n",
    "def lcm(x, y):\n",
    "   if x > y:\n",
    "       z = x\n",
    "   else:\n",
    "       z = y\n",
    "\n",
    "   while(True):\n",
    "       if((z % x == 0) and (z % y == 0)):\n",
    "           lcm = z\n",
    "           break\n",
    "       z += 1\n",
    "\n",
    "   return lcm\n",
    "print(lcm(4, 6))\n",
    "print(lcm(15, 17))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 31. Sum of three given integers. However, if two values are equal sum will be zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n",
      "0\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# Write a Python program to sum of three given integers. However, if two values are equal sum will be zero.\n",
    "\n",
    "def sum(x, y, z):\n",
    "    if x == y or y == z or x==z:\n",
    "        sum = 0\n",
    "    else:\n",
    "        sum = x + y + z\n",
    "    return sum\n",
    "\n",
    "print(sum(2, 1, 2))\n",
    "print(sum(3, 2, 2))\n",
    "print(sum(2, 2, 2))\n",
    "print(sum(1, 2, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 32. Sum of two given integers. However, if the sum is between 15 to 20 it will return 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "12\n",
      "22\n"
     ]
    }
   ],
   "source": [
    "# Write a Python program to sum of two given integers. However, if the sum is between 15 to 20 it will return 20.\n",
    "\n",
    "def sum(x, y):\n",
    "    sum = x + y\n",
    "    if sum in range(15, 20):\n",
    "        return 20\n",
    "    else:\n",
    "        return sum\n",
    "\n",
    "print(sum(10, 6))\n",
    "print(sum(10, 2))\n",
    "print(sum(10, 12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 33. Return true if the two given int values are equal or their sum or difference is 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Write a Python program which will return true if the two given integer values are equal or their sum or difference is 5.\n",
    "\n",
    "def test_number5(x, y):\n",
    "    if x == y or abs(x-y) == 5 or (x+y) == 5:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "print(test_number5(7, 2))\n",
    "print(test_number5(3, 2))\n",
    "print(test_number5(2, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 34. Add two objects if both objects are an integer type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "# Write a Python program to add two objects if both objects are an integer type.\n",
    "\n",
    "def add_numbers(a, b):\n",
    "    if not (isinstance(a, int) and isinstance(b, int)):\n",
    "         raise TypeError(\"Inputs must be integers\")\n",
    "    return a + b\n",
    "\n",
    "print(add_numbers(10, 20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 35. Display your details like name, age, address in three different lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Shashank\n",
      "Age: 27\n",
      "Address: Noida, India\n"
     ]
    }
   ],
   "source": [
    "# Write a Python program to display your details like name, age, address in three different lines.\n",
    "\n",
    "def personal_details():\n",
    "    name, age = \"Shashank\", 27\n",
    "    address = \"Noida, India\"\n",
    "    print(\"Name: {}\\nAge: {}\\nAddress: {}\".format(name, age, address))\n",
    "\n",
    "personal_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 36. Python program to solve (x + y) * (x + y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(14 + 13) ^ 2) = 729\n"
     ]
    }
   ],
   "source": [
    "# Write a Python program to solve (x + y) * (x + y).\n",
    "\n",
    "\n",
    "x, y = 14, 13\n",
    "result = x * x + 2 * x * y + y * y\n",
    "print(\"({} + {}) ^ 2) = {}\".format(x, y, result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 37. Future value of a specified principal amount, rate of interest, and a number of years"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12722.79\n"
     ]
    }
   ],
   "source": [
    "# Write a Python program to compute the future value of a specified principal amount, rate of interest, and a number of years.\n",
    "\n",
    "\n",
    "amt = 10000\n",
    "int = 3.5\n",
    "years = 7\n",
    "\n",
    "future_value  = amt*((1+(0.01*int)) ** years)\n",
    "print(round(future_value,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 38. Compute the distance between two points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.324555320336759\n"
     ]
    }
   ],
   "source": [
    "# Write a Python program to compute the distance between the points (x1, y1) and (x2, y2).\n",
    "\n",
    "import math\n",
    "p1 = [4, 0]\n",
    "p2 = [6, 6]\n",
    "distance = math.sqrt( ((p1[0]-p2[0])**2)+((p1[1]-p2[1])**2) )\n",
    "\n",
    "print(distance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 39. "
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "Python Excercise1.ipynb",
   "provenance": []
  },
  "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": 1
}