Assignment 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Assignment 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Average of best 2 marks\n",
    "Design a Python program to find the average of best two marks out of three marks taken as input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-20T03:25:28.629238Z",
     "start_time": "2019-03-20T03:25:24.875930Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter 3 numbers\n",
      "3\n",
      "4\n",
      "5\n",
      "4.5\n"
     ]
    }
   ],
   "source": [
    "print(\"Enter 3 numbers\")\n",
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "avg = max((a + b) / 2, (a + c) / 2, (b + c) / 2)\n",
    "print(avg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Student details\n",
    "Write a program to read the following input from user and display.\n",
    "1. Name \n",
    "2. USN \n",
    "3. Roll No\n",
    "4. Mobile No\n",
    "5. E-Mail id \n",
    "6. Percentage of Marks "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-20T03:34:48.380563Z",
     "start_time": "2019-03-20T03:32:18.914698Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number of students: 3\n",
      "Enter the name: Sanjay\n",
      "Enter the usn: 77\n",
      "Enter the roll number: 42\n",
      "Enter the mobile number: 7987689675\n",
      "Enter the email id: sanjaymg.is16@sahyadri.edu.in\n",
      "Enter the percentage: 89\n",
      "Enter the name: Mahesh\n",
      "Enter the usn: 43\n",
      "Enter the roll number: 70\n",
      "Enter the mobile number: 8858975767\n",
      "Enter the email id: maheshn.is16@sahyadri.edu.in\n",
      "Enter the percentage: 95\n",
      "Enter the name: Akshay\n",
      "Enter the usn: 11\n",
      "Enter the roll number: 9\n",
      "Enter the mobile number: 8762317931\n",
      "Enter the email id: akshayr.is16@sahyadri.edu.in\n",
      "Enter the percentage: 76\n",
      "The details are\n",
      "Name\tUSN\tRoll No\tMobile No\tEmail id1\tPercentage\n",
      "Sanjay\t77\t42\t7987689675\tsanjaymg.is16@sahyadri.edu.in\t89\n",
      "Mahesh\t43\t70\t8858975767\tmaheshn.is16@sahyadri.edu.in\t95\n",
      "Akshay\t11\t9\t8762317931\takshayr.is16@sahyadri.edu.in\t76\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter number of students: \"))\n",
    "names = []\n",
    "usns = []\n",
    "roll_nos = []\n",
    "mobiles = []\n",
    "emails = []\n",
    "marks = []\n",
    "for i in range(0, n):\n",
    "    names.append(input(\"Enter the name: \"))\n",
    "    usns.append(input(\"Enter the usn: \"))\n",
    "    roll_nos.append(input(\"Enter the roll number: \"))\n",
    "    mobiles.append(input(\"Enter the mobile number: \"))\n",
    "    emails.append(input(\"Enter the email id: \"))\n",
    "    marks.append(input(\"Enter the percentage: \"))\n",
    "print(\"The details are\")\n",
    "print(\"Name\\tUSN\\tRoll No\\tMobile No\\tEmail id1\\tPercentage\")\n",
    "for i in range(0, n):\n",
    "    print(names[i] + \"\\t\" + usns[i] + \"\\t\" + roll_nos[i] + \"\\t\" + mobiles[i] + \"\\t\" + emails[i] +\n",
    "          \"\\t\" + marks[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Well bracketed\n",
    "A string with parentheses is well bracketed if all parentheses are matched: every opening bracket\n",
    "has a matching closing bracket and vice versa. Write a Python function wellbracketed(s) that\n",
    "takes a string s containing parentheses and returns True if s is well bracketed and False otherwise.\n",
    "Here are some examples to show how your function should work.<br>\n",
    "```\n",
    ">>>wellbracketed(\"22)\")\n",
    "False\n",
    ">>>wellbracketed(\"(a+b)(a-b)\")\n",
    "True\n",
    ">>>wellbracketed(\"(a(b+c)-d)((e+f)\")\n",
    "False\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-20T03:41:45.326848Z",
     "start_time": "2019-03-20T03:41:16.238791Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a expression: (\"22)\")\n",
      "False\n",
      "Enter a expression: \"(a+b)(a-b)\"\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def well_bracketed():\n",
    "    s = input(\"Enter a expression: \")\n",
    "    c = 0\n",
    "    for i in range(0, len(s)):\n",
    "        if s[i] == '(':\n",
    "            c = c + 1\n",
    "        if s[i] == ')':\n",
    "            c = c - 1\n",
    "    if c == 0:\n",
    "        print(\"True\")\n",
    "    else:\n",
    "        print(\"False\")\n",
    "\n",
    "well_bracketed()\n",
    "well_bracketed()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sum of Squares\n",
    "A positive integer m is a sum of squares if it can be written as k + x where k > 0, x > 0 and both\n",
    "k and x are perfect squares. Write a Python function sumofsquares(m) that takes an integer m\n",
    "returns True if m is a sum of squares and False otherwise. Here are some examples to show how\n",
    "your function should work.\n",
    "```\n",
    ">>> sumofsquares(41)\n",
    "True\n",
    ">>> sumofsquares(30)\n",
    "False\n",
    ">>> sumofsquares(17)\n",
    "True\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-20T03:41:16.193451Z",
     "start_time": "2019-03-20T03:37:11.147027Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 41\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "\n",
    "def sum_of_squares(n):\n",
    "    a = int(math.sqrt(n))\n",
    "    for i in range(0, a + 1):\n",
    "        for j in range(0, a + 1):\n",
    "            if (i**2) + (j**2) == n:\n",
    "                return True\n",
    "    return False\n",
    "\n",
    "\n",
    "n = int(input(\"Enter a number: \"))\n",
    "print(sum_of_squares(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute grade\n",
    "Write a program to prompt for a score between 0.0 and 1.0. If the score is out of range, print an\n",
    "error message. If the score is between 0.0 and 1.0, print a grade using the following table.\n",
    "{Note: Create a function called computegrade that takes a score as its parameter and returns a\n",
    "grade as a string.}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-17T19:03:03.834515Z",
     "start_time": "2019-03-17T19:03:01.867173Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a grade:wed\n",
      "Not a valid type\n"
     ]
    }
   ],
   "source": [
    "def compute_grade(grade):\n",
    "    if grade > 0.8:\n",
    "        return 'A'\n",
    "    elif grade > 0.7:\n",
    "        return 'B'\n",
    "    elif grade > 0.6:\n",
    "        return 'C'\n",
    "    elif grade > 0.5:\n",
    "        return 'D'\n",
    "    elif grade > 0.4:\n",
    "        return 'E'\n",
    "    else:\n",
    "        return 'F'\n",
    "\n",
    "\n",
    "try:\n",
    "    grade = float(input(\"Enter a grade:\"))\n",
    "    if 0.0 <= grade <= 1.0:\n",
    "        print(compute_grade(grade))\n",
    "    else:\n",
    "        print(\"Invalid entry\")\n",
    "except ValueError:\n",
    "    print(\"Not a valid type\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reverse a string\n",
    "Write a program to reverse a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter string:yes\n",
      "Reversed string: sey\n"
     ]
    }
   ],
   "source": [
    "s = input(\"Enter string:\")\n",
    "print(\"Reversed string: \" + s[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Display palindrome\n",
    "Write a program to display all the palindrome words appearing in an input text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-17T19:08:22.093734Z",
     "start_time": "2019-03-17T19:08:08.595001Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a text:hello aa\n",
      "aa\n"
     ]
    }
   ],
   "source": [
    "s = input(\"Enter a text:\")\n",
    "word_list = s.split()\n",
    "\n",
    "for word in word_list:\n",
    "    if word == word[::-1]:\n",
    "        print(word)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print ASCII code\n",
    "Write a python program to display the ASCII code of the given character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = input(\"Enter a character: \")\n",
    "print(\"ASCII value of \" + s + \" is \", ord(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute score\n",
    "Write a python program to compute percentage score of a student by reading his scores in 6\n",
    "subjects, also display the name and score of the subject with highest and lowest score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-17T19:19:16.216806Z",
     "start_time": "2019-03-17T19:19:06.922728Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter marks for the first subject:67\n",
      "Enter marks for the second subject:78\n",
      "Enter marks for the third subject:98\n",
      "Enter marks for the fourth subject:56\n",
      "Enter marks for the fifth subject:76\n",
      "Enter marks for the sixth subject:67\n",
      "Score: 73.66666666666667\n",
      "Max: 98.0\n",
      "Min: 56.0\n"
     ]
    }
   ],
   "source": [
    "m1 = float(input(\"Enter marks for the first subject:\"))\n",
    "m2 = float(input(\"Enter marks for the second subject:\"))\n",
    "m3 = float(input(\"Enter marks for the third subject:\"))\n",
    "m4 = float(input(\"Enter marks for the fourth subject:\"))\n",
    "m5 = float(input(\"Enter marks for the fifth subject:\"))\n",
    "m6 = float(input(\"Enter marks for the sixth subject:\"))\n",
    "score_list = [m1, m2, m3, m4, m5, m6]\n",
    "print(\"Score:\", sum(score_list) / len(score_list))\n",
    "print(\"Max:\", max(score_list))\n",
    "print(\"Min:\", min(score_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute gross pay\n",
    "Write a python program to prompt the user for hours and rate per hour to compute gross pay."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-17T19:22:52.757572Z",
     "start_time": "2019-03-17T19:22:50.414862Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of hours:8\n",
      "Enter the rate:12\n",
      "Gross pay: 96.0\n"
     ]
    }
   ],
   "source": [
    "hours = int(input(\"Enter the number of hours:\"))\n",
    "rate = float(input(\"Enter the rate:\"))\n",
    "gross_pay = hours * rate\n",
    "print(\"Gross pay:\", gross_pay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Temperature Conversion\n",
    "Write a program which prompts the user for a Celsius temperature, covert the temperature to\n",
    "Fahrenheit, and print out the converted temperature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the temperature in Celsius:0\n",
      "Temperature in Fahrenheit is  32.0\n"
     ]
    }
   ],
   "source": [
    "c = float(input(\"Enter the temperature in Celsius:\"))\n",
    "f = float((c * 1.8) + 32)\n",
    "print(\"Temperature in Fahrenheit is \", f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flipping bits\n",
    "Write a python program to read a number A which contains only digits 0's and 1's. Check if it is\n",
    "possible to make all the digits same by just flipping one digit. Print 'YES' if flipping results in\n",
    "making all digit’s same else print 'NO'.\n",
    "\n",
    "| Test Case     | Input   | Output   |\n",
    "| ------------- | ------- | -------- |\n",
    "| Test Case 1   | 10      | YES      |\n",
    "| Test Case 2   | 1011    | YES      |\n",
    "| Test Case 3   | 0011    | NO       |\n",
    "| Test Case 4   | 11      | NO       |\n",
    "| Test Case 5   | 10      | YES      |\n",
    "| Test Case 6   | 0       | YES      |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-28T06:07:20.356236Z",
     "start_time": "2019-03-28T06:07:17.240907Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a binary number:101\n",
      "YES\n"
     ]
    }
   ],
   "source": [
    "a = input(\"Enter a binary number:\")\n",
    "num_ones = 0\n",
    "num_zeroes = 0\n",
    "for bit in a:\n",
    "    if bit == '0':\n",
    "        num_zeroes += 1\n",
    "    if bit == '1':\n",
    "        num_ones += 1\n",
    "if num_ones == 1 or num_zeroes == 1:\n",
    "    print(\"YES\")\n",
    "else:\n",
    "    print(\"NO\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prime numbers in range\n",
    "Write a program to list out all prime numbers between two integers m and n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter the range: \n",
      "3\n",
      "19\n",
      "Prime numbers between  3  and  19  are\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "print(\"Enter the range: \")\n",
    "m = int(input())\n",
    "n = int(input())\n",
    "print(\"Prime numbers between \", m, \" and \", n, \" are\")\n",
    "for i in range(m, n + 1):\n",
    "    if i > 1:\n",
    "        for j in range(2, i):\n",
    "            if (i % j) == 0:\n",
    "                break\n",
    "        else:\n",
    "            print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Frequencey of characters\n",
    "Write a program to count the frequency of characters in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter string: alsxm\n",
      "Frequency of all characters in alsxm is :\n",
      " {'a': 1, 'l': 1, 's': 1, 'x': 1, 'm': 1}\n"
     ]
    }
   ],
   "source": [
    "s = input(\"Enter string: \")\n",
    "freq = {}\n",
    "for i in s:\n",
    "    if i in freq:\n",
    "        freq[i] += 1\n",
    "    else:\n",
    "        freq[i] = 1\n",
    "print(\"Frequency of all characters in \" + s + \" is :\\n \" + str(freq))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String method\n",
    "Write a Python function to get a string made of the first 2 and the last 2 chars from a given string.\n",
    "If the string length is less than 2, return empty string, otherwise return new string created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-17T19:39:38.928931Z",
     "start_time": "2019-03-17T19:39:38.921713Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pprr'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def str_method(s):\n",
    "    if len(s) < 2:\n",
    "        return ''\n",
    "    else:\n",
    "        return s[:2] + s[-2:]\n",
    "    \n",
    "str_method(\"ppqqrr\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Display string without spaces\n",
    "Consider a string `s = “Hello how are you?”`. Write a program to display this string without spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, how are you?\n",
      "Hello,howareyou?\n"
     ]
    }
   ],
   "source": [
    "s = \"Hello, how are you?\"\n",
    "print(s)\n",
    "s = s.replace(\" \", \"\")\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Remove odd index values in a string\n",
    "Write a Python program to remove the characters which have odd index values of a given string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:abcde\n",
      "ace\n"
     ]
    }
   ],
   "source": [
    "def odd_values_string(str):\n",
    "    result = \"\"\n",
    "    for i in range(len(str)):\n",
    "        if i % 2 == 0:\n",
    "            result = result + str[i]\n",
    "    return result\n",
    "\n",
    "\n",
    "s = input(\"Enter a string:\")\n",
    "print(odd_values_string(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Last character exchange\n",
    "Write a Python program to change a given string to a new string where the first and last chars\n",
    "have been exchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:abcde\n",
      "ebcda\n"
     ]
    }
   ],
   "source": [
    "s = input(\"Enter a string:\")\n",
    "temp_beg = s[0]\n",
    "temp_end = s[-1]\n",
    "new_s = temp_end + s[1:-1] + temp_beg\n",
    "print(new_s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add 'ing' and 'ly'\n",
    "Write a Python program to add 'ing' at the end of a given string (length should be at least 3). If\n",
    "the given string already ends with 'ing' then add 'ly' instead. If the string length of the given string\n",
    "is less than 3, leave it unchanged.<br>\n",
    "Sample String : 'abc'<br>\n",
    "Expected Result : 'abcing'<br>\n",
    "Sample String : 'string'<br>\n",
    "Expected Result : 'stringly‘<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-18T06:39:09.138575Z",
     "start_time": "2019-03-18T06:39:05.645127Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:sds\n",
      "sdsing\n"
     ]
    }
   ],
   "source": [
    "s = input(\"Enter a string:\")\n",
    "if len(s) >= 3:\n",
    "    if s[-3:] == 'ing':\n",
    "        s += 'ly'\n",
    "    else:\n",
    "        s += 'ing'\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fibonacci and factorial\n",
    "Write a python program to generate first n Fibonacci number and factorial of n using functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number:5\n",
      "Factorial:\n",
      "120\n",
      "Fibonacci\n",
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    fact = 1\n",
    "    for i in range(1, n + 1):\n",
    "        fact = fact * i\n",
    "    print(fact)\n",
    "\n",
    "\n",
    "def fibonacci(n):\n",
    "    fib1 = 0\n",
    "    fib2 = 1\n",
    "    fib3 = fib1 + fib2\n",
    "    print(fib1)\n",
    "    print(fib2)\n",
    "    for i in range(2, n):\n",
    "        print(fib3)\n",
    "        fib1 = fib2\n",
    "        fib2 = fib3\n",
    "        fib3 = fib1 + fib2\n",
    "\n",
    "\n",
    "try:\n",
    "    n = int(input(\"Enter a number:\"))\n",
    "    print(\"Factorial:\")\n",
    "    factorial(n)\n",
    "    print(\"Fibonacci\")\n",
    "    fibonacci(n)\n",
    "except ValueError:\n",
    "    print(\"Not an integer.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HCF and LCM\n",
    "Write a program to find HCF and LCM of number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a value for a:10\n",
      "Enter a value for b:35\n",
      "5\n",
      "70\n"
     ]
    }
   ],
   "source": [
    "def hcf(x, y):\n",
    "    while (y):\n",
    "        x, y = y, x % y\n",
    "    return x\n",
    "\n",
    "\n",
    "def lcm(x, y):\n",
    "    lcm = (x * y) // hcf(x, y)\n",
    "    return lcm\n",
    "\n",
    "\n",
    "a = int(input(\"Enter a value for a:\"))\n",
    "b = int(input(\"Enter a value for b:\"))\n",
    "\n",
    "print(hcf(a, b))\n",
    "print(lcm(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String operations\n",
    "Write a python program to illustrate reverse, compare, copy and concatenate operations on\n",
    "strings without using built in functions, also compute lengths of the strings being read without\n",
    "using `len()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string a:Hello\n",
      "Enter a string b:Kenobi\n",
      "olleH\n",
      "False\n",
      "Hello\n",
      "HelloKenobi\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a = input(\"Enter a string a:\")\n",
    "b = input(\"Enter a string b:\")\n",
    "c = ''\n",
    "new_string = ''\n",
    "new_string = a[::-1]\n",
    "print(new_string)\n",
    "\n",
    "print(a == b)\n",
    "\n",
    "for ch in a:\n",
    "    c += ch\n",
    "print(c)\n",
    "\n",
    "c = a + b\n",
    "print(c)\n",
    "\n",
    "count = 0\n",
    "for ch in a:\n",
    "    count += 1\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Horner's method\n",
    "Write a python program to evaluate the polynomial \\begin{equation*} f'(x) = a_4x^4 + a_3x^3 + a_2x^2 + a_1x + a_0 \\end{equation*} for a given value of x and its coefficients using Horner's method.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a value for a0:0\n",
      "Enter a value for a1:1\n",
      "Enter a value for a2:2\n",
      "Enter a value for a3:3\n",
      "Enter a value for a4:4\n",
      "Enter the value for x:2\n",
      "The value of polynomial at x = 2 is 26\n"
     ]
    }
   ],
   "source": [
    "def horner(poly, n, x):\n",
    "    result = poly[0]\n",
    "    for i in range(1, n):\n",
    "        result = result * x + poly[i]\n",
    "    print(\"The value of polynomial at x = \" + str(x) + \" is \" + str(result))\n",
    "\n",
    "\n",
    "a0 = int(input(\"Enter a value for a0:\"))\n",
    "a1 = int(input(\"Enter a value for a1:\"))\n",
    "a2 = int(input(\"Enter a value for a2:\"))\n",
    "a3 = int(input(\"Enter a value for a3:\"))\n",
    "a4 = int(input(\"Enter a value for a4:\"))\n",
    "\n",
    "poly = [a0, a1, a2, a3, a4]\n",
    "x = int(input(\"Enter the value for x:\"))\n",
    "n = len(poly)\n",
    "horner(poly, n, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decimal to binary\n",
    "Write a python program to convert decimal number to it’s equivalent binary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a decimal value:10\n",
      "0b1010\n",
      "[1, 0, 1, 0]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "dec_val = int(input(\"Enter a decimal value:\"))\n",
    "bin_val = bin(dec_val)\n",
    "print(bin_val)\n",
    "temp_dec = dec_val\n",
    "rem = int()\n",
    "l = []\n",
    "while temp_dec != 0:\n",
    "    rem = temp_dec % 2\n",
    "    l.insert(0, int(rem))\n",
    "    temp_dec //= 2\n",
    "print(l)\n",
    "len(l)\n",
    "s = str()\n",
    "while ch in l:\n",
    "    s += l[t]\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## is_prime()\n",
    "Write a python function `is_prime(num)` that accepts an integer argument and returns 1 if the\n",
    "argument is prime, a 0 otherwise. Write a python program that invokes this function to generate\n",
    "prime numbers between the given ranges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the lower value:3\n",
      "Enter the upper value:13\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "def is_prime(a):\n",
    "    flag = 0\n",
    "    for i in range(2, a):\n",
    "        if a % i == 0:\n",
    "            flag = 1\n",
    "            break\n",
    "    if flag == 1:\n",
    "        return False\n",
    "    else:\n",
    "        return True\n",
    "\n",
    "\n",
    "lower = int(input(\"Enter the lower value:\"))\n",
    "upper = int(input(\"Enter the upper value:\"))\n",
    "\n",
    "for i in range(lower, upper + 1):\n",
    "    if is_prime(i):\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String replacement\n",
    "Write a python program to replace each constant in a string with the next one except letter ‘z’,\n",
    "‘Z’, ‘a’ and ‘A’. Thus the string `Programming is Fun` should be modified as `Qsphsannjoh jt gvo`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:program\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'qsphsan'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = input(\"Enter a string:\")\n",
    "new_s = ''\n",
    "ascii_val = 0\n",
    "for ch in s:\n",
    "    if ch not in ['Z', 'z', 'a', 'A']:\n",
    "        new_s += chr(ord(ch) + 1)\n",
    "    else:\n",
    "        new_s += ch\n",
    "new_s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File operations\n",
    "Write a program to read through a file and print the contents of the file (line by line) all in upper\n",
    "case, also count number of characters, words and lines in a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-17T19:45:17.237813Z",
     "start_time": "2019-03-17T19:45:17.203682Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SOME RANDOM STRING\n",
      "\n",
      "ANOTHER RANDOM STRING\n",
      "\n",
      "THIRD RANDOM STRING\n",
      "\n",
      "CGPA:9.7\n",
      "\n",
      "CGPA:8.5\n",
      "\n",
      "NEXT STRING\n",
      "6 13 90\n"
     ]
    }
   ],
   "source": [
    "line_count = 0\n",
    "char_count = 0\n",
    "word_count = 0\n",
    "s = ''\n",
    "with open(\"text_file.txt\", 'r') as file:\n",
    "    for line in file:\n",
    "        words = line.split()\n",
    "        line_count += 1\n",
    "        word_count += len(words)\n",
    "        char_count += len(line)\n",
    "        print(line.upper())\n",
    "print(line_count, word_count, char_count)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Search file for CGPA\n",
    "Write a program to prompt for a file name, and then read through the file and look for lines of\n",
    "the form:<br>\n",
    "CGPA: 9.7<br>\n",
    "When a line that starts with “CGPA:” is encountered, pull apart the line to extract the floating-\n",
    "point number on the line. Count these lines and then compute the total of the CGPA. When the\n",
    "end of file is reached, print out the average CGPA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a file name:text_file.txt\n",
      "Sum:  18.2  Mean:  9.1\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "file_name = input(\"Enter a file name:\")\n",
    "file = open(file_name, 'r')\n",
    "cgpa_list = []\n",
    "temp = []\n",
    "for line in file:\n",
    "    if line.startswith(\"CGPA:\"):\n",
    "        temp = re.findall(\"[0-9]+.[0-9]+\", line)\n",
    "        if len(temp) == 1:\n",
    "            cgpa = float(temp[0])\n",
    "            cgpa_list.append(cgpa)\n",
    "        temp = []\n",
    "    else:\n",
    "        continue\n",
    "print(\"Sum: \", sum(cgpa_list), \" Mean: \", sum(cgpa_list) / len(cgpa_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Search file for string\n",
    "Write a program to search and print all the lines starting with a specific word (taken as keyboard\n",
    "input) in a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the search string:CGPA\n",
      "CGPA:9.7\n",
      "\n",
      "CGPA:8.5\n",
      "\n"
     ]
    }
   ],
   "source": [
    "s = input(\"Enter the search string:\")\n",
    "file = open(\"text_file.txt\", 'r')\n",
    "for line in file:\n",
    "    if line.startswith(s):\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Student Name - USN file operations\n",
    "Given two university information files “studentname.txt” and “usn.txt” that contains students\n",
    "Name and USN respectively. Write a python program to create a new file called “output.txt” and\n",
    "copy the content of files “studentname.txt” and “usn.txt” into output file in the sequence shown\n",
    "below. Display the contents of output file “output.txt” on to the screen.\n",
    "<img src=\"table.png\" height=600px width=500px>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Akshay': '4SF16IS012', 'Mahesh': '4SF16IS801', 'Ashik': '4SF16IS045', 'Harshith': '4SF16IS909'}\n"
     ]
    }
   ],
   "source": [
    "student_file = open(\"studentname.txt\", 'r')\n",
    "usn_file = open(\"usn.txt\", 'r')\n",
    "student_list = []\n",
    "usn_list = []\n",
    "for line in student_file:\n",
    "    student_list.append(line.rstrip())\n",
    "for line in usn_file:\n",
    "    usn_list.append(line.rstrip())\n",
    "\n",
    "student_usn_dict = dict(zip(student_list, usn_list))\n",
    "print(student_usn_dict)\n",
    "with open(\"output.txt\", 'w') as output_file:\n",
    "    output_file.write(\"Student Name\\tUSN\\n\")\n",
    "    for key, val in student_usn_dict.items():\n",
    "        #     print(key, val)\n",
    "        output_file.write(key + \"\\t\" + val + \"\\n\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": "1.",
   "nav_menu": {
    "height": "539px",
    "width": "256px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "273.2px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}