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": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Factorial\n",
    "def FindFactorial(N):\n",
    "    fact = 1\n",
    "    for i in range(N,0,-1):\n",
    "        fact = fact*i\n",
    "    return fact\n",
    "\n",
    "FindFactorial(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Perfect Numbers\n",
    "def isPerfectNumber(N):\n",
    "    factorsList = []\n",
    "    for i in range(1,(N//2)+1):\n",
    "        if(N%i==0):\n",
    "            factorsList.append(i)\n",
    "            \n",
    "    FatorsSum = sum(factorsList)\n",
    "    if(FatorsSum == N):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "            \n",
    "\n",
    "print(isPerfectNumber(28))\n",
    "print(isPerfectNumber(6))\n",
    "print(isPerfectNumber(27))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5040\n"
     ]
    }
   ],
   "source": [
    "# nPr\n",
    "# Write a program to calculate nPr. nPr represents n permutation r and value of nPr is (n!) / (n-r)!.\n",
    "\n",
    "def findPermutation(N,R):\n",
    "    NFact = FindFactorial(N)\n",
    "    NR = FindFactorial(N-R)\n",
    "    return NFact//NR\n",
    "    \n",
    "print(findPermutation(2,1))\n",
    "print(findPermutation(10,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# nCr\n",
    "def findCombination(N,R):\n",
    "    NFact = FindFactorial(N)\n",
    "    NR = FindFactorial(N-R)\n",
    "    RFact = FindFactorial(R)\n",
    "    return NFact//(RFact * NR)\n",
    "    \n",
    "print(findCombination(3,2))\n",
    "print(findCombination(4,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9969\n",
      "9999\n",
      "9999\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1323. Maximum 69 Number\n",
    "\n",
    "Given a positive integer num consisting only of digits 6 and 9.\n",
    "\n",
    "Return the maximum number you can get by changing at most one digit (6 becomes 9, and 9 becomes 6).\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: num = 9669\n",
    "Output: 9969\n",
    "Explanation: \n",
    "Changing the first digit results in 6669.\n",
    "Changing the second digit results in 9969.\n",
    "Changing the third digit results in 9699.\n",
    "Changing the fourth digit results in 9666. \n",
    "The maximum number is 9969.\n",
    "\n",
    "\n",
    "Example 2:\n",
    "\n",
    "Input: num = 9996\n",
    "Output: 9999\n",
    "Explanation: Changing the last digit 6 to 9 results in the maximum number.\n",
    "\n",
    "\n",
    "Example 3:\n",
    "\n",
    "Input: num = 9999\n",
    "Output: 9999\n",
    "Explanation: It is better not to apply any change.\n",
    " \n",
    "\n",
    "Constraints:\n",
    "\n",
    "1 <= num <= 10^4\n",
    "num's digits are 6 or 9.\n",
    "\"\"\"\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def maximum69Number (self, num: int) -> int:\n",
    "        strNum = list(str(num))\n",
    "        for i in range(len(strNum)):\n",
    "            if strNum[i] == '6':\n",
    "                strNum.pop(i)\n",
    "                strNum.insert(i,'9')\n",
    "                break;\n",
    "        return int(''.join(strNum))\n",
    "    \n",
    "sol = Solution()\n",
    "\n",
    "print(sol.maximum69Number(9669))\n",
    "print(sol.maximum69Number(9996))\n",
    "print(sol.maximum69Number(9999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "-2\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "29. Divide Two Integers\n",
    "\n",
    "Given two integers dividend and divisor, divide two integers without using multiplication, division and mod operator.\n",
    "\n",
    "Return the quotient after dividing dividend by divisor.\n",
    "\n",
    "The integer division should truncate toward zero, which means losing its fractional part. For example, truncate(8.345) = 8 and truncate(-2.7335) = -2.\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: dividend = 10, divisor = 3\n",
    "Output: 3\n",
    "Explanation: 10/3 = truncate(3.33333..) = 3.\n",
    "\n",
    "\n",
    "Example 2:\n",
    "\n",
    "Input: dividend = 7, divisor = -3\n",
    "Output: -2\n",
    "Explanation: 7/-3 = truncate(-2.33333..) = -2.\n",
    "\n",
    "Note:\n",
    "\n",
    "- Both dividend and divisor will be 32-bit signed integers.\n",
    "- The divisor will never be 0.\n",
    "- Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−231,  231 − 1]. For the purpose of this problem, assume that your function returns 231 − 1 when the division result overflows.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "class Solution:\n",
    "    def divide(self, dividend: int, divisor: int) -> int:\n",
    "        result  =  dividend/(divisor)\n",
    "        if result >= pow(2,31):\n",
    "            result = result -1\n",
    "        return int(result)\n",
    "    \n",
    "sol = Solution()\n",
    "print(sol.divide(10,3))\n",
    "print(sol.divide(7,-3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "9. Palindrome Number\n",
    "\n",
    "Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward.\n",
    "\n",
    "\n",
    "Example 1:\n",
    "\n",
    "Input: 121\n",
    "Output: true\n",
    "\n",
    "\n",
    "Example 2:\n",
    "\n",
    "Input: -121\n",
    "Output: false\n",
    "Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.\n",
    "\n",
    "\n",
    "Example 3:\n",
    "\n",
    "Input: 10\n",
    "Output: false\n",
    "Explanation: Reads 01 from right to left. Therefore it is not a palindrome.\n",
    "\n",
    "\"\"\"\n",
    "class Solution:\n",
    "    def isPalindrome(self, x: int) -> bool:\n",
    "        s = str(x)\n",
    "        rs = \"\".join(list(reversed(s)))\n",
    "        \n",
    "        if rs != s:\n",
    "            return False\n",
    "        return True\n",
    "                \n",
    "sol = Solution()\n",
    "print(sol.isPalindrome(121))\n",
    "print(sol.isPalindrome(-121))  \n",
    "print(sol.isPalindrome(10)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '2', 'Fizz', '4', 'Buzz', 'Fizz', '7', '8', 'Fizz', 'Buzz', '11', 'Fizz', '13', '14', 'FizzBuzz']\n",
      "['1']\n",
      "['1', '2', 'Fizz', '4', 'Buzz']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Write a program that outputs the string representation of numbers from 1 to n.\n",
    "\n",
    "But for multiples of three it should output “Fizz” instead of the number and for the multiples of five output “Buzz”. For numbers which are multiples of both three and five output “FizzBuzz”.\n",
    "\n",
    "Example:\n",
    "\n",
    "n = 15,\n",
    "\n",
    "Return:\n",
    "[\n",
    "    \"1\",\n",
    "    \"2\",\n",
    "    \"Fizz\",\n",
    "    \"4\",\n",
    "    \"Buzz\",\n",
    "    \"Fizz\",\n",
    "    \"7\",\n",
    "    \"8\",\n",
    "    \"Fizz\",\n",
    "    \"Buzz\",\n",
    "    \"11\",\n",
    "    \"Fizz\",\n",
    "    \"13\",\n",
    "    \"14\",\n",
    "    \"FizzBuzz\"\n",
    "]\n",
    "\"\"\"\n",
    "from typing import List\n",
    "class Solution:\n",
    "    def fizzBuzz(self, n: int) -> List[str]:\n",
    "        lst = []\n",
    "        \n",
    "        for i in range(1,n+1):\n",
    "            if i%3==0 and i%5==0:\n",
    "                lst.append('FizzBuzz')\n",
    "            elif i%3==0:\n",
    "                lst.append('Fizz')\n",
    "            elif i%5 == 0:\n",
    "                lst.append('Buzz')\n",
    "            else:\n",
    "                lst.append(str(i))\n",
    "        return lst\n",
    "    \n",
    "sol = Solution()\n",
    "print(sol.fizzBuzz(15))\n",
    "print(sol.fizzBuzz(1))  \n",
    "print(sol.fizzBuzz(5)) "
   ]
  },
  {
   "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}