Day_11_JN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem solving and Programming\n",
    "\n",
    "### Day 11\n",
    "### Date-9 May 2019"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Related Problems in Day 4 and Day 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 1:\n",
    "### Design a program to evaluate the polynomial\n",
    "f(x)= x^3 + 2 X^2 + 3 X - 10 for x in the range [1, 1000]\n",
    "#### Constraints:\n",
    "x,f(x)\n",
    "#### Test Cases\n",
    "* x=100;f(x)=395\n",
    "* x=2324;f(x)=Invalid\n",
    "* x=-123;f(x)=Invalid\n",
    "* x=345;f(x)=2031"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x=100 then f(100) is 395\n",
      "x=2324 then f(2324) is Invalid.Enter x between 1 to 1000\n",
      "x=-123 then f(-123) is Invalid.Enter x between 1 to 1000\n",
      "x=345 then f(345) is 2031\n"
     ]
    }
   ],
   "source": [
    "def function(x):\n",
    "    if(0<x<1000):\n",
    "        return(x^3+ 2*x^2 +3*x -10)\n",
    "    else:\n",
    "        return(\"Invalid.Enter x between 1 to 1000\")\n",
    "     \n",
    "        \n",
    "print(\"x=100 then f(100) is\",function(100))\n",
    "print(\"x=2324 then f(2324) is\",function(2324))\n",
    "print(\"x=-123 then f(-123) is\",function(-123))\n",
    "print(\"x=345 then f(345) is\",function(345))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 2:\n",
    "### Designing program for Basic Arithmetic operations\n",
    "#### Constraints:\n",
    "Values\n",
    "\n",
    "#### Test Cases\n",
    "* Add(2+3)=5\n",
    "* sub(7-4)=3\n",
    "* div(45 / 5 )=9\n",
    "* mul(4 x 5)=20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "3\n",
      "9.0\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "def Add(a,b):\n",
    "    return(a+b)\n",
    "def Sub(c,d):\n",
    "    return(max(c,d)-min(c,d))\n",
    "def Div(e,f):\n",
    "    return(e/f)\n",
    "def Mul(g,h):\n",
    "    return(g*h)\n",
    "print(Add(2,3))\n",
    "print(Sub(7,4))\n",
    "print(Div(45,5))\n",
    "print(Mul(4,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 3:\n",
    "### Procedure to print N natural numbers.\n",
    "#### Constraints:\n",
    "n\n",
    "#### Test Cases\n",
    "natural(5) -> 1 , 2 , 3 , 4 , 5 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "def natural(n):\n",
    "    for i in range (1,n+1):\n",
    "        print(i)\n",
    "natural(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 4:\n",
    "### Procedure to calculate the factorial of a given number\n",
    "#### Constraints:\n",
    "n\n",
    "#### Test Cases\n",
    "Factorial(5) ->120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def Factorial(n):\n",
    "    f=1\n",
    "    for i in range (1,n+1):\n",
    "        f=f*i\n",
    "    return(f)\n",
    "Factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 5:\n",
    "### Statement:\n",
    "Given an int n, return True if it is within 10 of 100 or 200. Note: abs(num) computes the absolute value of a number.\n",
    "#### Constraints:\n",
    "n\n",
    "#### Test Cases:\n",
    "* near_hundred(93) → True\n",
    "* near_hundred(90) → True\n",
    "* near_hundred(89) → False\n",
    "* near_hundred(192) → True    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "near_hundred(93) is True\n",
      "near_hundred(90) is True\n",
      "near_hundred(89) is False\n",
      "near_hundred(192) is True\n"
     ]
    }
   ],
   "source": [
    "def near_hundred(n):\n",
    "    return(90 <= n <= 100 or 190 <= n <= 200)\n",
    "print(\"near_hundred(93) is\",near_hundred(93))\n",
    "print(\"near_hundred(90) is\",near_hundred(90))\n",
    "print(\"near_hundred(89) is\",near_hundred(89))\n",
    "print(\"near_hundred(192) is\",near_hundred(192))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 6:\n",
    "### Statement:\n",
    "Given 2 int values, return True if one is negative and one is positive. Except if the third parameter  is True, then return True only if first two parameters are negative.\n",
    "#### Constraints:\n",
    "Parameter1,Parameter2,Boolen value\n",
    "#### Test Cases:\n",
    "* pos_neg(1, -1, False) → True\n",
    "* pos_neg(-1, 1, False) → True\n",
    "* pos_neg(-4, -5, True) → True\n",
    "* pos_neg(1 , 6, True)  → False\n",
    "* pos_neg(-1, -9, False) → False\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def pos_neg(n1,n2,b):\n",
    "    return(n1<0 and n2>0 and b==False)or (n1>0 and n2<0 and b==False) or (n1<0 and n2<0 and b==True)\n",
    "        \n",
    "print(pos_neg(1, -1, False))\n",
    "print(pos_neg(-1, 1, False))\n",
    "print(pos_neg(-4, -5, True))\n",
    "print(pos_neg( 1 , 6, True))\n",
    "print(pos_neg(-1, -9, False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 7:\n",
    "### Statement:\n",
    "Create a Random number Generator which takes range(lb,ub) and returns the random number in the given range.lb<randomnumber<ub.\n",
    "#### Constraints:\n",
    "lower bound (lb) ,upper bound (ub)\n",
    "#### Test Cases:\n",
    "* RandomGenerator(1,100) --> (1,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "67"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random \n",
    "def randomGenerator(lb,ub):\n",
    "    return random.randint(lb,ub)\n",
    "randomGenerator(1,101)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 8:\n",
    "### Statement:\n",
    "Given an integer n ,calculate the sum of n random numbers in the range [0,1000000000000000]. \n",
    "#### Constraints:\n",
    "limit -> lower bound,upper bound.\n",
    "#### Test Cases:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48434025235395962"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "def sumRandomNumbers(n,lb,ub):\n",
    "    sum=0\n",
    "    for count in range(1,n+1):\n",
    "        sum= sum + random.randint(lb,ub)\n",
    "       \n",
    "    return sum\n",
    "sumRandomNumbers(100,1,1000000000000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 9:\n",
    "### Statement:\n",
    "Procedure to generate multiplication tables. \n",
    "#### Constraints:\n",
    "Table name, initial value final value\n",
    "#### Test Cases:\n",
    "* MT(3, 5, 7)   \n",
    "   * -> 3 X 5 = 15\n",
    "   * -> 3 X 6 = 18\n",
    "   * -> 3 X 7 = 21\n",
    "               \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 x 5 = 15\n",
      "3 x 6 = 18\n",
      "3 x 7 = 21\n"
     ]
    }
   ],
   "source": [
    "def mulTable(i,s,e):\n",
    "    v=1\n",
    "    for c in range (s,e+1):\n",
    "        v=i*c\n",
    "        print(i,\"x\",c,\"=\", v )\n",
    "mulTable(3,5,7)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 10:\n",
    "### Statement:\n",
    "Procedure to print the list of factors of a given number. \n",
    "#### Constraints:\n",
    "factor n\n",
    "#### Test Cases:\n",
    "* FactorList(6)  ->  1 2 3 6\n",
    "\n",
    "  FactorList (9) ->   1 3 9\n",
    "\n",
    "  FactorList (19) ->  1  19\n",
    "               \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "6  \n",
      "1\n",
      "9  \n",
      "1\n",
      "19  \n"
     ]
    }
   ],
   "source": [
    "def Factors(n):\n",
    "    for i in range(1,n):\n",
    "        if(n%i==0):\n",
    "            print(i)\n",
    "        else:\n",
    "            return n\n",
    "print(Factors(6),\" \")\n",
    "print(Factors(9),\" \")\n",
    "print(Factors(19),\" \")            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 11:\n",
    "### Statement:\n",
    "Program to check if a given number is Prime and returns a Boolean value.\n",
    "#### Constraints:\n",
    "\n",
    "#### Test Cases:\n",
    "IsPrime(100) -> False\n",
    "IsPrime(97) -> True \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def prime(n):\n",
    "    if(n==2 or n==3 or n==5 or n==7 ):\n",
    "        return True\n",
    "    if(n%2==0 or n%3==0 or n%5==0 or n%7==0):\n",
    "        return False\n",
    "    else:\n",
    "        return True\n",
    "print(prime(100))\n",
    "print(prime(97))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 12:\n",
    "### Statement:\n",
    "Procedure to count the number of digits in a given number.\n",
    "#### Constraints:\n",
    "\n",
    "#### Test Cases:\n",
    "* CountDigits(123456) ->  6\n",
    "* CountDigits (0) ->  1\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "def count_digits(n):\n",
    "    for i in range\n",
    "count_digits(16400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 13:\n",
    "### Statement:\n",
    "Procedure to check if a given number is a Perfect Number. ( Perfect number is a number for which the sum of all it's divisors is equal to the number itself)\n",
    "#### Constraints:\n",
    "\n",
    "#### Test Cases:\n",
    "* IsPerfect(3) -> False\n",
    "* IsPerfect (6) -> True\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def Perfect(n):\n",
    "    sum=0\n",
    "    for i in range (1,n):\n",
    "        if(n%i==0):        \n",
    "            sum=sum+i\n",
    "    if(sum==n):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "print(Perfect(3))\n",
    "print(Perfect(6))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 14:\n",
    "### Statement:\n",
    "Procedure to generate the first N perfect numbers. \n",
    "#### Constraints:\n",
    "\n",
    "#### Test Cases:\n",
    "* GeneratePerfect(2) ->  6   28\n",
    "* GeneratePerfect (4) ->  6   28   496    8128\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "def GenPerfect(n):\n",
    "    for i in range (1,n):\n",
    "        if(i == 2 or i==3 or i==5 or i==7):\n",
    "            perfect=((2^i)-1)*(2^(i-1))\n",
    "            print(perfect)\n",
    "        elif(i%2==0 or i%3==0 or i%5==0 or i%7==0  ):\n",
    "            perfect=((2^i)-1)*(2^(i-1))\n",
    "            print(perfect)\n",
    "GenPerfect(4)        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 6 Related Problems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 15:\n",
    "### Statement:\n",
    "Design a procedure to perform Linear search on list of N unsorted unique numbers. It take an array and the key element to be searched and returns the index of the element of key element if found. Else returns -1\n",
    "#### Constraints:\n",
    "\n",
    "#### Test Cases:\n",
    "* Linearsearch([1,4,9,0,8,5,6],4) ->1\n",
    "* Linearsearch([12,342,56,12,776,89],776) ->4\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def linearSearch(a,key):\n",
    "    for i in range (0,len(a)):\n",
    "        if(a[i]==key):\n",
    "            return i\n",
    "    return -1\n",
    "print(linearSearch([1,4,9,0,8,5,6],4))\n",
    "print(linearSearch([12,342,56,12,776,89],776))      \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 16:\n",
    "### Statement:\n",
    "Design a procedure calculate the maximum, minimum and average of N numbers\n",
    "#### Constraints:\n",
    "\n",
    "#### Test Cases:\n",
    "* data( a[1,2,3,4,5] ) -> Max = 5, Min = 1, Avg = 3\n",
    "* data( a[3,2,5,7,6,5] ) -> Max = 9, Min = 2, Avg = 5.333\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum of a is 5\n",
      "minimum of a is 1\n",
      "3.0\n",
      "None\n",
      "maximum of a is 9\n",
      "minimum of a is 2\n",
      "5.0\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def max_min_avg(a):\n",
    "    print('maximum of a is', max(a))\n",
    "    print('minimum of a is', min(a))\n",
    "    sum=1\n",
    "    for i in range (1,len(a)):\n",
    "        sum=sum+a[i]\n",
    "    print( sum/(len(a)))\n",
    "print(max_min_avg([1,2,3,4,5]))\n",
    "print(max_min_avg([3,2,5,7,6,9]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 17:\n",
    "### Statement:\n",
    "Design a procedure to determine if a given string is a Palindrome\n",
    "#### Constraints:\n",
    "\n",
    "#### Test Cases:\n",
    "* Palindrome(\"racecar\") -> True\n",
    "* Palindrome(\"raptor\") -> False\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def palindrome(s):\n",
    "    if(s==s[::-1]):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "print(palindrome('racecar'))\n",
    "print(palindrome('raptor'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 18:\n",
    "### Statement:\n",
    "Design a procedure to calculate the squareroot of a number \"without using the math function sqrt\".\n",
    "#### Constraints:\n",
    "\n",
    "#### Test Cases:\n",
    "* Squareroot(36) -> 6\n",
    "* Squareroot(144) -> 12\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.0\n",
      "12.0\n"
     ]
    }
   ],
   "source": [
    "def sqroot(n):\n",
    "    return(n**0.5)\n",
    "print(sqroot(36))\n",
    "print(sqroot(144))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 19:\n",
    "### Statement:\n",
    "Design a procedure to determine the frequency count of numbers in a given list#### Constraints:\n",
    "\n",
    "#### Test Cases:\n",
    "* Frequency( a[1,3,2,1] ) -> 1 : 2, 2 : 1, 3 : 1\n",
    "* Frequency( a[2,6,5,4,9,5,2,1,4,1,4,1,4,1,2,6,3,,84,7,] ) -> 1 : 2, 2 : 1, 3 : 1\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 : 1\n",
      "2 : 2\n",
      "1 : 3\n",
      "[1, 3, 2, 1]\n",
      "6 : 2\n",
      "6 : 3\n",
      "3 : 4\n",
      "8 : 5\n",
      "7 : 6\n",
      "[2, 6, 6, 3, 8, 7]\n"
     ]
    }
   ],
   "source": [
    "def frequency(a):\n",
    "    c=1\n",
    "    for i in range (1,len(a)):\n",
    "        for j in range (2,len(a)):\n",
    "            if(a[i]==a[j]):\n",
    "                c=c+1\n",
    "        print(a[i],\":\",c)\n",
    "    return a \n",
    "         \n",
    "print(frequency([1,3,2,1]))\n",
    "print(frequency([2,6,6,3,8,7,]))\n",
    "                \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}