Python_Warm_Up.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiplication table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def table():\n",
    "    num = input('Input\\t:')\n",
    "    for i in range(1,11,1):\n",
    "        print('{} times {} equals {}'.format(i, num, i*float(num)))\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input\t:8\n",
      "1 times 8 equals 8.0\n",
      "2 times 8 equals 16.0\n",
      "3 times 8 equals 24.0\n",
      "4 times 8 equals 32.0\n",
      "5 times 8 equals 40.0\n",
      "6 times 8 equals 48.0\n",
      "7 times 8 equals 56.0\n",
      "8 times 8 equals 64.0\n",
      "9 times 8 equals 72.0\n",
      "10 times 8 equals 80.0\n"
     ]
    }
   ],
   "source": [
    "table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Twin primes and prime factors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sieve(max_num):\n",
    "    sv = list(range(2, max_num+1, 1))\n",
    "    for i, num in enumerate(sv):\n",
    "        if num is not -1:\n",
    "            j=i+num\n",
    "            while(j<len(sv)):\n",
    "                sv[j]=-1\n",
    "                j+=num\n",
    "                \n",
    "    return sv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test=sieve(15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, -1, 5, -1, 7, -1, -1, -1, 11, -1, 13, -1, -1]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def twinPrimes(max_num):\n",
    "    s=sieve(max_num)\n",
    "    s=s[1:] # remove 2 - only even prime\n",
    "    s=list(filter(lambda x : x>0, s))\n",
    "    for i, num in enumerate(s):\n",
    "        if i < len(s)-1:\n",
    "            print(str(num) + ' ' + str(s[i+1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 5\n",
      "5 7\n",
      "7 11\n",
      "11 13\n",
      "13 17\n",
      "17 19\n",
      "19 23\n",
      "23 29\n",
      "29 31\n",
      "31 37\n",
      "37 41\n",
      "41 43\n",
      "43 47\n",
      "47 53\n",
      "53 59\n",
      "59 61\n",
      "61 67\n",
      "67 71\n",
      "71 73\n",
      "73 79\n",
      "79 83\n",
      "83 89\n",
      "89 97\n",
      "97 101\n",
      "101 103\n",
      "103 107\n",
      "107 109\n",
      "109 113\n",
      "113 127\n",
      "127 131\n",
      "131 137\n",
      "137 139\n",
      "139 149\n",
      "149 151\n",
      "151 157\n",
      "157 163\n",
      "163 167\n",
      "167 173\n",
      "173 179\n",
      "179 181\n",
      "181 191\n",
      "191 193\n",
      "193 197\n",
      "197 199\n",
      "199 211\n",
      "211 223\n",
      "223 227\n",
      "227 229\n",
      "229 233\n",
      "233 239\n",
      "239 241\n",
      "241 251\n",
      "251 257\n",
      "257 263\n",
      "263 269\n",
      "269 271\n",
      "271 277\n",
      "277 281\n",
      "281 283\n",
      "283 293\n",
      "293 307\n",
      "307 311\n",
      "311 313\n",
      "313 317\n",
      "317 331\n",
      "331 337\n",
      "337 347\n",
      "347 349\n",
      "349 353\n",
      "353 359\n",
      "359 367\n",
      "367 373\n",
      "373 379\n",
      "379 383\n",
      "383 389\n",
      "389 397\n",
      "397 401\n",
      "401 409\n",
      "409 419\n",
      "419 421\n",
      "421 431\n",
      "431 433\n",
      "433 439\n",
      "439 443\n",
      "443 449\n",
      "449 457\n",
      "457 461\n",
      "461 463\n",
      "463 467\n",
      "467 479\n",
      "479 487\n",
      "487 491\n",
      "491 499\n",
      "499 503\n",
      "503 509\n",
      "509 521\n",
      "521 523\n",
      "523 541\n",
      "541 547\n",
      "547 557\n",
      "557 563\n",
      "563 569\n",
      "569 571\n",
      "571 577\n",
      "577 587\n",
      "587 593\n",
      "593 599\n",
      "599 601\n",
      "601 607\n",
      "607 613\n",
      "613 617\n",
      "617 619\n",
      "619 631\n",
      "631 641\n",
      "641 643\n",
      "643 647\n",
      "647 653\n",
      "653 659\n",
      "659 661\n",
      "661 673\n",
      "673 677\n",
      "677 683\n",
      "683 691\n",
      "691 701\n",
      "701 709\n",
      "709 719\n",
      "719 727\n",
      "727 733\n",
      "733 739\n",
      "739 743\n",
      "743 751\n",
      "751 757\n",
      "757 761\n",
      "761 769\n",
      "769 773\n",
      "773 787\n",
      "787 797\n",
      "797 809\n",
      "809 811\n",
      "811 821\n",
      "821 823\n",
      "823 827\n",
      "827 829\n",
      "829 839\n",
      "839 853\n",
      "853 857\n",
      "857 859\n",
      "859 863\n",
      "863 877\n",
      "877 881\n",
      "881 883\n",
      "883 887\n",
      "887 907\n",
      "907 911\n",
      "911 919\n",
      "919 929\n",
      "929 937\n",
      "937 941\n",
      "941 947\n",
      "947 953\n",
      "953 967\n",
      "967 971\n",
      "971 977\n",
      "977 983\n",
      "983 991\n",
      "991 997\n"
     ]
    }
   ],
   "source": [
    "twinPrimes(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def primeFactors(num):\n",
    "    s=sieve(num)\n",
    "    s=list(filter(lambda x : x>0, s))\n",
    "    primes=[]\n",
    "    for n in s:\n",
    "        while num % n is 0:\n",
    "            primes.append(n)\n",
    "            num=int(num/n)\n",
    "    \n",
    "    print(primes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 2, 2, 7]\n"
     ]
    }
   ],
   "source": [
    "primeFactors(56)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Combinatorics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def nPr(n, r):\n",
    "    return reduce(lambda x, y: x*y ,list(range(n, n-r, -1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nPr(10,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def nCr(n, r):\n",
    "    return int(nPr(n,r)/fact(r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fact(r):\n",
    "    if r==1: return 1\n",
    "    return r*fact(r-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nCr(10,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decimal to binary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "hex2Bin={\n",
    "    '0':'0000',\n",
    "    '1':'0001',\n",
    "    '2':'0010',\n",
    "    '3':'0011',\n",
    "    '4':'0100',\n",
    "    '5':'0101',\n",
    "    '6':'0110',\n",
    "    '7':'0111',\n",
    "    '8':'1000',\n",
    "    '9':'1001',\n",
    "    'a':'1010',\n",
    "    'b':'1011',\n",
    "    'c':'1100',\n",
    "    'd':'1101',\n",
    "    'e':'1110',\n",
    "    'f':'1111',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def dec2Bin(dec):\n",
    "    h=hex(dec)\n",
    "    s=str(h)[2:]\n",
    "    bi=''\n",
    "    for c in s:\n",
    "        bi+=hex2Bin[c]\n",
    "    print(bi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s='76'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0111'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hex2Bin['7']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01001100\n"
     ]
    }
   ],
   "source": [
    "dec2Bin(76)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Armstrong number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "371"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3**3+7**3+1**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def isArmstrong(num):\n",
    "    if num == sumOfCubes(num):\n",
    "        return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sumOfCubes(num):\n",
    "    a=str(num)\n",
    "    sum=0\n",
    "    for c in a:\n",
    "        sum+=int(c)**3\n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isArmstrong(371)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Product of digits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def prodDigit(num):\n",
    "    a=str(num)\n",
    "    prod=1\n",
    "    for c in a:\n",
    "        prod*=int(c)\n",
    "    return prod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prodDigit(43)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiplicative persistence and Multiplicative digital root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def MDR_MPersistence(num):\n",
    "    s=str(num)\n",
    "    persistence=0\n",
    "    while len(s) > 1:\n",
    "        s=str(prodDigit(int(s)))\n",
    "        persistence+=1\n",
    "    return int(s), persistence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MDR_MPersistence(341)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sum of proper divisors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sumPdivisors(num):\n",
    "    s=0\n",
    "    d=1\n",
    "    while d <= num/2:\n",
    "        if int(num % d) == 0:\n",
    "            s+=d\n",
    "        d+=1\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sumPdivisors(36)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+2+3+4+6+9+18+12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Perfect numbers in given range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def perfectSet(r):\n",
    "    start=r[0]\n",
    "    end=r[1]\n",
    "    \n",
    "    for n in range(start, end+1, 1):\n",
    "        if isPerfect(n):\n",
    "            print(n)\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def isPerfect(n):\n",
    "    return n==sumPdivisors(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28\n"
     ]
    }
   ],
   "source": [
    "perfectSet((27, 30))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Amicable numbers in a range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def amicableSet(r):\n",
    "    start=r[0]\n",
    "    end=r[1]\n",
    "    \n",
    "    for n in range(start, end+1, 1):\n",
    "        for n_ in range(n, end+1, 1):\n",
    "            if isAmicablePair(n, n_):\n",
    "                print(str(n)+' '+str(n_))\n",
    "    \n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def isAmicablePair(n, n_):\n",
    "    return (sumPdivisors(n)==n_) and (sumPdivisors(n_)==n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "220 284\n"
     ]
    }
   ],
   "source": [
    "amicableSet((219,285))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Filter odd numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filterOdd(l):\n",
    "    return list(filter(lambda x: x%2 is not 0,l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 19, 95]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filterOdd([0,2,5,8,19,20,34,95])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cubic map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cubeMap(l):\n",
    "    return list(map(lambda x:x**3, l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 8, 27, 64]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cubeMap([1,2,3,4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Even cubes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def evenCubes(l):\n",
    "    return cubeMap(list(filter(lambda x:x%2==0, l)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 8, 512, 8000, 39304]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evenCubes([0,2,5,8,19,20,34,95])"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}