Mathematical .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55555 44444 33333 22222 11111 \n",
      "44444 33333 22222 11111 \n",
      "33333 22222 11111 \n",
      "22222 11111 \n",
      "11111 \n"
     ]
    }
   ],
   "source": [
    "# Print the pattern | Set-1 \n",
    "def printPatternSet1(N):\n",
    "    for i in range(N,0,-1):\n",
    "        for j in range(i,0,-1):\n",
    "            pStr = str(j)\n",
    "            print(N*pStr,end=\" \")\n",
    "        print(\"\")\n",
    "printPatternSet1(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Series AP\n",
    "def FindNthAP(series,N):\n",
    "    d = series[1]-series[0];\n",
    "    a = series[0];\n",
    "    ap = (a + (N-1)*d)\n",
    "    return ap\n",
    "\n",
    "print(FindNthAP([2,3],4)) \n",
    "print(FindNthAP([1,2],10)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Series GP\n",
    "def FindNthGP(series,N):\n",
    "    r = series[1]/series[0];\n",
    "    a = series[0];\n",
    "    GP = (a*r^(N-1))\n",
    "    return GP\n",
    "\n",
    "print(FindNthAP([2,3],1)) \n",
    "print(FindNthAP([1,2],2)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pallendrom\n",
      "Not Pallendrom\n"
     ]
    }
   ],
   "source": [
    "def checkPallendrom(number):\n",
    "    temp = number\n",
    "    rev=0\n",
    "    while(number>0):\n",
    "        r = number%10;\n",
    "        rev = rev*10+r\n",
    "        number = number//10\n",
    "       \n",
    "    if(rev==temp):\n",
    "        return 'Pallendrom';\n",
    "    else:\n",
    "        return 'Not Pallendrom'\n",
    "\n",
    "\n",
    "def sumNumber(number):\n",
    "    finalNumber = 0\n",
    "    while(number>0):\n",
    "        r = number%10;\n",
    "        finalNumber = finalNumber+r\n",
    "#         rev = rev*10+r\n",
    "        number = number//10\n",
    "    return finalNumber\n",
    "        \n",
    "\n",
    "print(checkPallendrom(sumNumber(56)))\n",
    "print(checkPallendrom(sumNumber(98)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pallendrom'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkPallendrom(11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "44\n",
      "136\n"
     ]
    }
   ],
   "source": [
    "def binaryToDecimal(binary):\n",
    "    temp = binary\n",
    "    sumation = []\n",
    "    power =0\n",
    "    while (binary>0):\n",
    "        r = binary%10\n",
    "        binary = binary//10\n",
    "        sumation.append(r*(2**power))\n",
    "        power = power +1\n",
    "    return sum(sumation)\n",
    "    \n",
    "\n",
    "print(binaryToDecimal(101100))\n",
    "print(binaryToDecimal(10001000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "101100\n",
      "10001000\n"
     ]
    }
   ],
   "source": [
    "def DecimalToBinary(decimal):\n",
    "    temp = decimal\n",
    "    bLst = []\n",
    "    while (decimal>0):\n",
    "        r = decimal % 2\n",
    "        decimal = decimal//2\n",
    "        bLst.append(r)\n",
    "    return ''.join(map(str, bLst[::-1]))\n",
    "        \n",
    "\n",
    "print(DecimalToBinary(44))\n",
    "print(DecimalToBinary(136))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 21, 23, 32, 34, 43, 45, 54, 56, 65, 67, 76, 78, 87, 89, 98, 121, 123, 212, 232, 234, 321, 323, 343, 345, 432, 434, 454, 456, 543, 545, 565, 567, 654, 656, 676, 678, 765, 767, 787, 789, 876, 878, 898, 987, 989, 1212, 1232, 1234, 2121, 2123, 2321, 2323, 2343, 2345, 3212, 3232, 3234, 3432, 3434, 3454, 3456, 4321, 4323, 4343, 4345, 4543, 4545, 4565, 4567, 5432, 5434, 5454, 5456, 5654, 5656, 5676, 5678, 6543, 6545, 6565, 6567, 6765, 6767, 6787, 6789, 7654, 7656, 7676, 7678, 7876, 7878, 7898, 8765, 8767, 8787, 8789, 8987, 8989, 9876, 9878, 9898]\n"
     ]
    }
   ],
   "source": [
    "def checkJumpingNumber(N):\n",
    "    difference = 0\n",
    "    digits = []\n",
    "    iszeroflag = 0\n",
    "    while(N>0):\n",
    "        digit = N%10\n",
    "        N = N//10\n",
    "        digits.append(digit)\n",
    "        if(digit == 0):\n",
    "            iszeroflag = 1\n",
    "            return False\n",
    "    \n",
    "    for i in range(len(digits)-1):\n",
    "        if(not(abs(digits[i]-digits[i+1])==1)):\n",
    "            return False\n",
    "    \n",
    "    \n",
    "    return True\n",
    "    \n",
    "\n",
    "\n",
    "# Jumping Numbers \n",
    "def jumpingNumbers(N):\n",
    "    loopRange = N//10;\n",
    "    jnList = []\n",
    "    if(loopRange == 0):\n",
    "        return [i for i in range(10)]\n",
    "    \n",
    "    for i in range(10,N):\n",
    "        if(checkJumpingNumber(i)):\n",
    "            jnList.append(i)\n",
    "        \n",
    "    print(jnList)\n",
    "            \n",
    "jumpingNumbers(10000)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkJumpingNumber(4343456)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Prime Number\n",
    "def checkPrimeNumber(N):\n",
    "    for i in range(2,(N//2)+1):\n",
    "#         print(N%i)\n",
    "        if(N%i==0):\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "\n",
    "checkPrimeNumber(6)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n"
     ]
    }
   ],
   "source": [
    "# Print N prime numbers\n",
    "def primeNumbers(N):\n",
    "    pList = []\n",
    "    for i in range(2,N+1):\n",
    "        if(checkPrimeNumber(i)):\n",
    "            pList.append(i)\n",
    "    return pList\n",
    "    \n",
    "print(primeNumbers(100))           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sum of all prime numbers between 1 and N.\n",
    "\n",
    "def sumOfPrimeNumbers(N):\n",
    "    return sum(primeNumbers(N))\n",
    "\n",
    "sumOfPrimeNumbers(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n"
     ]
    }
   ],
   "source": [
    "# ref GeeksforGeeks\n",
    "def SieveOfEratosthenes(N):\n",
    "    primeLst = [True for i in range(N+1)]\n",
    "\n",
    "    primeLst[0] = False \n",
    "    primeLst[1] = False\n",
    "\n",
    "    start = 2;\n",
    "    while (start * start <= N):\n",
    "        if(primeLst[start] == True):\n",
    "            for i in range(start*start,N+1,start):\n",
    "                primeLst[i] = False\n",
    "        start = start+1\n",
    "        \n",
    "    newLst = [i for i in range(2,N+1) if primeLst[i] == True]\n",
    "    print(newLst)\n",
    "        \n",
    "    \n",
    "SieveOfEratosthenes(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Armstrong Numbers-> Yes\n"
     ]
    }
   ],
   "source": [
    "# Armstrong Numbers\n",
    "def checkArmstrongNumbers(num):\n",
    "    temp = num;\n",
    "    cubedNumber = 0\n",
    "    \n",
    "    while (num > 0):\n",
    "        r = num % 10 ;\n",
    "        cubedNumber += r ** 3\n",
    "        num = num//10\n",
    "        \n",
    "    if(cubedNumber == temp):\n",
    "        return 'Yes'\n",
    "    else:\n",
    "        return 'No'\n",
    "        \n",
    "print('Armstrong Numbers->',checkArmstrongNumbers(371))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "-18\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "# Closest Number\n",
    "def returnClosestNumber(N,M):\n",
    "    r = N%M\n",
    "    left = N-r\n",
    "    right = N+(M-r)\n",
    "    diff = [abs(N-left),abs(N-right)]\n",
    "    if(diff[0]<=diff[1]):\n",
    "        return left\n",
    "    else: \n",
    "        return right\n",
    "    return [left,right,test]\n",
    "\n",
    "print(returnClosestNumber(13,4))\n",
    "print(returnClosestNumber(-15,6))\n",
    "print(returnClosestNumber(15,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 40]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sumOfTwo(a, b, v):\n",
    "    for i in range(len(a)):\n",
    "        for j in range(len(b)):\n",
    "            if(a[i]+b[j] == v):\n",
    "                return [a[i],b[j]];\n",
    "    return False\n",
    "sumOfTwo([1, 2, 3],[10, 20, 30, 40],42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Print the Kth Digit\n",
    "def kthDigit(a,b,k):\n",
    "    num = a**b\n",
    "    temp = num\n",
    "    numList = []\n",
    "    while(num>0):\n",
    "        r = num%10\n",
    "        num = num//10\n",
    "        numList.append(r)\n",
    "        \n",
    "        \n",
    "    return numList[::-1][k-1]\n",
    "\n",
    "\n",
    "print(kthDigit(3,3,1))\n",
    "print(kthDigit(5,2,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 2], [2, 3], [3, 2]]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Prime Number\n",
    "def checkPrimeNumber(N):\n",
    "    for i in range(2,(N//2)+1):\n",
    "#         print(N%i)\n",
    "        if(N%i==0):\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "\n",
    "# Print N prime numbers\n",
    "def primeNumbers(N):\n",
    "    pList = []\n",
    "    for i in range(2,N+1):\n",
    "        if(checkPrimeNumber(i)):\n",
    "            pList.append(i)\n",
    "    return pList\n",
    "    \n",
    "\n",
    "# Pairs of prime number\n",
    "def pairsofPrimeNumber(N):\n",
    "    primeNumbersList = primeNumbers(N//2)\n",
    "    pairsList = []\n",
    "    for i in range(len(primeNumbersList)):\n",
    "        for j in range(len(primeNumbersList)):\n",
    "            if(primeNumbersList[i]*primeNumbersList[j] <= N):\n",
    "                pairsList.append([primeNumbersList[i],primeNumbersList[j]])\n",
    "    return pairsList\n",
    "\n",
    "            \n",
    "pairsofPrimeNumber(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Largest prime factor\n",
    "def LargestPrimeFactor(N):\n",
    "    primeNumbersList = primeNumbers(N//2)\n",
    "    for i in reversed(primeNumbersList):\n",
    "        if(N%i == 0):\n",
    "            return i\n",
    "    \n",
    "print(LargestPrimeFactor(6))\n",
    "print(LargestPrimeFactor(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1281. Subtract the Product and Sum of Digits of an Integer\n",
    "Given an integer number n, return the difference between the product of its digits and the sum of its digits.\n",
    " \n",
    "Input: n = 234\n",
    "Output: 15 \n",
    "Explanation: \n",
    "Product of digits = 2 * 3 * 4 = 24 \n",
    "Sum of digits = 2 + 3 + 4 = 9 \n",
    "Result = 24 - 9 = 15\n",
    "\"\"\"\n",
    "from typing import List\n",
    "def subtractProductAndSum(n: int) -> int:\n",
    "    prod = 1;\n",
    "    sumation = 0\n",
    "    temp = n;\n",
    "    while temp > 0:\n",
    "        rem = temp%10\n",
    "        prod *= rem\n",
    "        sumation += rem\n",
    "        temp = temp // 10;\n",
    "    return prod - sumation\n",
    "\n",
    "print(subtractProductAndSum(234))"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}