To-Do (Loop).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w269kMywSK4V"
   },
   "source": [
    "## Write the code in Python for following problems:\n",
    "\n",
    "**<font color='red'>[Please follow variable naming conventions including using meaningful variable names for all the tasks]</font>**\n",
    "\n",
    "### Task 1\n",
    "\n",
    "Write python program, which prints the following sequences of values in loops:\n",
    "\n",
    "a)\t24, 18, 12, 6, 0, -6\\\n",
    "b)\t-10, -5, 0, 5, 10, 15, 20\\\n",
    "c)\t18, 27, 36, 45, 54, 63\\\n",
    "d)\t18, -27, 36, -45, 54, -63\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "**Hints(1):** Use a while loop for solving these problems.\n",
    "\n",
    "**Hints(2):** We are already familiar with the print() function. But when we use it to print any value it automatically adds an additional newline after each print statement.\n",
    "\n",
    "For example:\\\n",
    "print(1)\\\n",
    "print(2)\n",
    "\n",
    "Output:\\\n",
    "1\\\n",
    "2\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "To solve this problem, in Python3, we can add an extra argument (end = \" \") in the print function which tells the program to skip printing the additional newline.\n",
    "\n",
    "For example:\\\n",
    "print(1, end =\" \")\\\n",
    "print(2)\n",
    "\n",
    "Output: (prints the next output right to the previous one)\\\n",
    "12\n",
    "\n",
    "=====================================================================\n",
    "\n",
    "In Task-1(a), the loop counter should be initialized at 24 and the loop should terminate when the loop counter reaches -6. The difference between the first two values is 24 - 18 = 6. So the loop counter value is getting decremented by 6 in every iteration.\n",
    "\n",
    "For your understanding, task 1(a) code is done for you.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "H9nuTYCuSK4X",
    "outputId": "e1a08b2f-ccc1-4896-b1ec-5904ba1945d5",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24, 18, 12, 6, 0, -6"
     ]
    }
   ],
   "source": [
    "# a) 24, 18, 12, 6, 0, -6\n",
    "\n",
    "# initialize loop counter\n",
    "counter = 24\n",
    "\n",
    "# loop structure\n",
    "while counter >= -6:\n",
    "    \n",
    "    #inside loop body\n",
    "    if counter == -6:\n",
    "        print(counter, end = \"\") \n",
    "    else:\n",
    "        print(counter, end = \", \") \n",
    "     \n",
    "    counter = counter - 6 #updating loop counter\n",
    "    #inside loop body\n",
    "    \n",
    "#outside loop body"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10, -5, 0, 5, 10, 15, 20"
     ]
    }
   ],
   "source": [
    "#initialize loop counter\n",
    "counter =-10\n",
    "\n",
    "#loop structure\n",
    "\n",
    "while counter<=20:\n",
    "    \n",
    "    #inside loop body\n",
    "    if counter == 20:\n",
    "        print(counter,end= \"\")\n",
    "    else:\n",
    "        print(counter,end= \", \")\n",
    "    counter +=5 \n",
    "    \n",
    "    #updating loop counter #inside the loop body\n",
    "    \n",
    "#outside the body"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "b5blHg8zSK4n"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18, 27, 36, 45, 54, 63"
     ]
    }
   ],
   "source": [
    "# c)18, 27, 36, 45, 54, 63\n",
    "\n",
    "#initialize loop counter\n",
    "counter =18\n",
    "\n",
    "#loop structure\n",
    "while counter<=63:\n",
    "    \n",
    "    #inside loop body\n",
    "    if counter==63:\n",
    "        print(counter, end= \"\")\n",
    "    else:\n",
    "        print(counter, end= \", \")\n",
    "            \n",
    "    #updating loop body\n",
    "    counter = counter+9\n",
    "#outside the body"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VlRJZhqVSK4v"
   },
   "source": [
    "**Hints for 1(d):** \n",
    "\n",
    "print(5 * (-1)) gives output -5\\\n",
    "print(\"-\" + str(5)) gives output -5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "lA6BDPaaSK4v"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18, -27, 36, -45, 54, -63"
     ]
    }
   ],
   "source": [
    "# d)18,-27, 36,-45,54,-63\n",
    "\n",
    "#initialize loop counter\n",
    "counter=18\n",
    "\n",
    "#loop structer\n",
    "while counter<=63:\n",
    "    if counter % 2 == 0:\n",
    "        print(counter,end=\", \")\n",
    "    else:\n",
    "        print(-1*counter,end=\"\")\n",
    "        if counter==63:\n",
    "            print(\"\",end=\"\")\n",
    "        else:\n",
    "            print(\"\",end=\", \")\n",
    "        \n",
    "        #updating loop body\n",
    "        \n",
    "    counter= counter+9\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RGkTLNE8SK43"
   },
   "source": [
    "### Task 2\n",
    "Write a Python code for the following:\n",
    "\n",
    "1)\tAsk the user to enter the name of his favorite car.\\\n",
    "2)\tAsk the user to enter a Number\n",
    "\n",
    "Display the name of the user’s favorite car, the number of times specified in the second step.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:** If the user enters “Toyota” and 2, your program should print the name “Toyota” two times.\n",
    "\n",
    "**Input:**\\\n",
    "Toyota\\\n",
    "2\n",
    "\n",
    "**Output:**\\\n",
    "Toyota\\\n",
    "Toyota\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 02:** If the user enters “Veyron” and 5, your program should print the name “Veyron” five times.\n",
    "\n",
    "**Input:**\\\n",
    "Veyron\\\n",
    "5\n",
    "\n",
    "**Output:**\\\n",
    "Veyron\\\n",
    "Veyron\\\n",
    "Veyron\\\n",
    "Veyron\\\n",
    "Veyron\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "u5yX33mvSK45"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your favourite car name: BMW\n",
      "Enter your number: 100\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n",
      "BMW\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "car_name= input(\"Your favourite car name: \")\n",
    "\n",
    "number=int(input(\"Enter your number: \"))\n",
    "\n",
    "for counter in range(number):\n",
    "    print(car_name)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xT0l0U35SK5A"
   },
   "source": [
    "### Task 3\n",
    "Write a Python code of a program that adds all numbers that are multiples of **both 7 and 9** up to 600 (including 600).\n",
    "\n",
    "Output: 2835\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "Q6dix8WhSK5B"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2835\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "accumulation =0\n",
    "\n",
    "for result in range(1,601):\n",
    "    \n",
    "    if result%7==0 and result%9==0:\n",
    "        \n",
    "        accumulation+=result\n",
    "        \n",
    "print(accumulation)\n",
    "\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8swUoCy9SK5F"
   },
   "source": [
    "### Task 4\n",
    "Write a Python code of a program that adds all numbers that are multiples of **either 7 or 9** up to 600(including 600). \\\n",
    "Ensure that numbers like 63 are added only once in the sum.\n",
    "\n",
    "Output: 42649\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "pbIA-waFSK5G"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42649\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "accumulation = 0\n",
    "\n",
    "for result in range(1,601):\n",
    "    \n",
    "    if result%7==0 or result%9==0:\n",
    "        accumulation+=result\n",
    "\n",
    "print(accumulation)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "H3hLyguASK5L"
   },
   "source": [
    "### Task 5\n",
    "Write a Python code of a program that adds all numbers that are multiples of **either 7 or 9 but not both**, up to 600(including 600).\n",
    "\n",
    "Output: 39814\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "LiAvUr1QSK5M"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39814\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "accumulation =0\n",
    "\n",
    "for result in range (1,601):\n",
    "    \n",
    "    if(result%7==0 or result%9==0):\n",
    "        \n",
    "        if not (result%7==0 and result%9==0):\n",
    "            \n",
    "            accumulation+= result\n",
    "            \n",
    "print(accumulation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8SmvPvfaSK5P"
   },
   "source": [
    "### Task 6\n",
    "Write a Python code to displays all the **odd numbers** between 10 and 50.\n",
    "\n",
    "Output: 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "PJmT9fvuSK5Q"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 "
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "for result in range(10,51):\n",
    "    \n",
    "    if result %2!=0:\n",
    "        \n",
    "        print(result,end=\" \")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Nw4dX_MeSK5V"
   },
   "source": [
    "### Task 7\n",
    "Write a Python code that will calculate the **value of y if the expression** of y is as follows (n is the input):  \n",
    "\n",
    "$y = 1^2 - 2^2 +3^2 -4^2 +5^2 .........+ n^2 $\n",
    "\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:** \n",
    "\n",
    "**Input:**\\\n",
    "10\n",
    "\n",
    "**Output:**\\\n",
    "-55\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 02:** \n",
    "\n",
    "**Input:**\\\n",
    "20\n",
    "\n",
    "**Output:**\\\n",
    "-210\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "BbJe-7AuSK5V"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n: 20\n",
      "-210\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "accumulation =0\n",
    "\n",
    "input_number =int(input(\"Enter the value of n: \"))\n",
    "\n",
    "for i in range(1,input_number+1):\n",
    "    \n",
    "    if i%2==0:\n",
    "        accumulation=accumulation-pow(i,2)\n",
    "        \n",
    "    else:\n",
    "        accumulation=accumulation+pow(i,2)\n",
    "        \n",
    "        \n",
    "print(accumulation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SgvBqJ9PSK5l"
   },
   "source": [
    "### Task 8\n",
    "\n",
    "Write a Python code of a program that asks the user to enter ten numbers then display the total and the average of **ONLY** the **odd numbers** among those ten numbers. <font color='red'>[Please do not use list for this task]</font>\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:** \n",
    "\n",
    "**Input:**\\\n",
    "1\n",
    "\n",
    "2\n",
    "\n",
    "3\n",
    "\n",
    "4\n",
    "\n",
    "5\n",
    "\n",
    "6\n",
    "\n",
    "7\n",
    "\n",
    "8\n",
    "\n",
    "9\n",
    "\n",
    "10\n",
    "\n",
    "**Output:**\n",
    "Total is 25 and Average is 5.0\n",
    "\n",
    "\n",
    "**Explanation:**\n",
    "\n",
    "Total is 25 = (1+3+5+7+9) and Average is 25/5 = 5.0\n",
    "\n",
    "==========================================================\n",
    "\n",
    "\n",
    "**Example 02:** \n",
    "\n",
    "**Input:**\\\n",
    "-20\n",
    "\n",
    "3\n",
    "\n",
    "-5\n",
    "\n",
    "40\n",
    "\n",
    "-17\n",
    "\n",
    "9\n",
    "\n",
    "20\n",
    "\n",
    "-8\n",
    "\n",
    "99\n",
    "  \n",
    "-200\n",
    "\n",
    "**Output:**\n",
    "\n",
    "Total is 89 and Average is 17.8\n",
    "\n",
    "\n",
    "**Explanation:**\n",
    "\n",
    "Total is 89 = (3+(-5)+(-17)+9+99) and Average is 89/5 = 17.8\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "c0akirXXSK5m"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: -20\n",
      "Enter a number: 3\n",
      "Enter a number: -5\n",
      "Enter a number: 40\n",
      "Enter a number: -17\n",
      "Enter a number: 9\n",
      "Enter a number: 20\n",
      "Enter a number: -8\n",
      "Enter a number: 99\n",
      "Enter a number: -200\n",
      "Total is 89\n",
      "Average is  17.8\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "accumulation=0\n",
    "\n",
    "average=0\n",
    "\n",
    "flag=0\n",
    "\n",
    "for counter in range(10):\n",
    "    \n",
    "    number_input=int(input(\"Enter a number: \"))\n",
    "    \n",
    "    if number_input%2!=0:\n",
    "        \n",
    "        accumulation=accumulation+number_input\n",
    "        \n",
    "        flag+=1\n",
    "        \n",
    "average=accumulation/flag\n",
    "\n",
    "print(\"Total is\",accumulation)\n",
    "\n",
    "print(\"Average is \",average)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cGdMk_vuSK5s"
   },
   "source": [
    "### Task 9\n",
    "Write a Python code for the following:\n",
    "* Ask the user to enter a Number, N\n",
    "* Display the summation of multiples of 7 up to that number (**from 1 to N inclusive**)\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example01:** \n",
    "\n",
    "**Input:**\\\n",
    "50\n",
    "\n",
    "**Output:**\\\n",
    "196\n",
    "\n",
    "**Explanation:**\\\n",
    "7 + 14 + 21 + 28 + 35 + 42 + 49 = 196\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example02:** \n",
    "\n",
    "**Input:**\\\n",
    "75\n",
    "\n",
    "**Output:**\\\n",
    "385\n",
    "\n",
    "**Explanation:**\\\n",
    "7 + 14 + 21 + 28 + 35 + 42 + 49 + 56 + 63 + 70 = 385\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "zLsrA8dSSK5t"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 50\n",
      "196\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "accumulation =0\n",
    "\n",
    "input_number =int(input(\"Enter a number: \"))\n",
    "\n",
    "for counter in range(1,input_number+1):\n",
    "    \n",
    "    if(counter%7==0):\n",
    "        \n",
    "        accumulation=accumulation+counter\n",
    "        \n",
    "print(accumulation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OZ9pVIvhSK5w"
   },
   "source": [
    "### Task 10\n",
    "Write a Python code that will read 10 numbers from the user, and then print the first number, the sum of the first 2 numbers, the sum of the first 3 numbers, and so on up to the sum of 10 numbers.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "\n",
    "For example,\n",
    "\n",
    "The user enters 10, output 10, then \\\n",
    "The user enters 2, (10+2) = 12, output 12, then \\\n",
    "The user enters 4, (10+2+4) = 16, output 16, then \\\n",
    "The user enters 20, (10+2+4+20) = 36, output 36, and continues till the 10$^{th}$ input\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "FCwYrfGGSK5w"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 10\n",
      "10\n",
      "Enter a number: 2\n",
      "12\n",
      "Enter a number: 4\n",
      "16\n",
      "Enter a number: 20\n",
      "36\n",
      "Enter a number: 25\n",
      "61\n",
      "Enter a number: 30\n",
      "91\n",
      "Enter a number: 40\n",
      "131\n",
      "Enter a number: 50\n",
      "181\n",
      "Enter a number: 60\n",
      "241\n",
      "Enter a number: 70\n",
      "311\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "accumulation=0\n",
    "\n",
    "for i in range(10):\n",
    "    \n",
    "    input_number=int(input(\"Enter a number: \"))\n",
    "    \n",
    "    accumulation=accumulation+input_number\n",
    "    \n",
    "    print(accumulation)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xWxrM53vvfUV"
   },
   "source": [
    "\n",
    "\n",
    "\n",
    "### Task 11\n",
    "Write a Python program which takes a number and prints the digits from the unit place, then the tenth, then hundredth, etc. <font color='red'>(Right to Left)</font>\n",
    "\n",
    "<font color='red'>[Consider the input number to be an INTEGER. You are not allowed to use String indexing for solving this task]</font>\n",
    "\n",
    "**Example:** If the user gives 32768, then print 8, 6, 7, 2, 3 \n",
    "\n",
    "=========================================================================\n",
    "\n",
    "**Hint (1):**  The input() function, converts the input data to String data type by default. Therefore, please type cast it to an integer before proceeding further.\n",
    "\n",
    "\n",
    "**Hint  (2):** First to get the digit from the right side, we can take the remainder of the number using modulus (%) operator i.e. mod 10 to get the rightmost digit and print it. For dropping the last digit, we can perform floor division by 10 on the number and then continue the same to print the other digits as shown below.\n",
    "\n",
    "32768 % 10 = 8 \n",
    "\n",
    "32768 // 10 = 3276 \n",
    "\n",
    "Then,\n",
    "\n",
    "3276 % 10 = 6\n",
    "\n",
    "3276 // 10 = 327 \n",
    "\n",
    "and so on\n",
    "\n",
    "327 % 10 = 7 \n",
    "\n",
    "327 // 10 = 32 \n",
    "\n",
    "32 % 10 = 2 \n",
    "\n",
    "32 // 10 = 3 \n",
    "\n",
    "3 % 10 = 3 \n",
    "\n",
    "3 // 10 = 0 \n",
    "\n",
    "Done! When the number becomes 0 you can end your loop.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "2Ntfdr2tv230"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter value: 32768\n",
      "8, 6, 7, 2, 3"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "number_input=int(input(\"Enter value: \"))\n",
    "\n",
    "while (number_input>0):\n",
    "    \n",
    "    accumulation=number_input%10\n",
    "    \n",
    "    if number_input<10:\n",
    "        print(accumulation,end=\"\")\n",
    "        \n",
    "    else:\n",
    "        print(accumulation,end=\", \")\n",
    "        \n",
    "    number_input=number_input//10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VIeR6DT9SK53"
   },
   "source": [
    "### Task 12\n",
    "\n",
    "Write a Python program that takes a number and prints how many digits are in that number. \\\n",
    "<font color='red'>[Consider the input number to be an INTEGER.]</font>\n",
    "\n",
    "<font color='red'>[You are not allowed to use len() function]</font>\n",
    "\n",
    "**Example:** If the user gives 9876, your program should print 4. \n",
    "\n",
    "\n",
    "\n",
    "**Hint:** We may keep floor dividing by ten and count how many times this can be done until the number becomes 0 as illustrated below. \n",
    "\n",
    "9876 // 10 = 987, count = 1 \\\n",
    "then, 987 // 10 = 98, count = 2 \\\n",
    "98 // 10 = 9, count = 3 \\\n",
    "9 // 10 = 0, count = 4 \n",
    "\n",
    "Done! When the number becomes 0 your loop can end giving you the count of digits, in this case for our input of 9876, 4 digits.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "6uX3wr_gSK51"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter value: 9876\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "counter=0\n",
    "\n",
    "input_number=int(input(\"Enter value: \"))\n",
    "\n",
    "while (input_number>0):\n",
    "    \n",
    "    input_number=input_number//10\n",
    "    \n",
    "    counter+=1\n",
    "    \n",
    "print(counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dUsVuzILSK50"
   },
   "source": [
    "### Task 13\n",
    "Write a Python program that takes a number from the user and prints its digits from  <font color='red'> left to right. </font>\n",
    "\n",
    "<font color='red'>[Consider the input number to be an INTEGER. You are not allowed to use String indexing for solving this task]</font>\n",
    "\n",
    "=========================================================================\n",
    "\n",
    "**Example:** if the user gives 32768, then print 3, 2, 7, 6, 8 \n",
    "\n",
    "=========================================================================\n",
    "\n",
    "**Hint(1):**  The input() function takes the input data as String data type by default. Please convert it to an integer before starting your code for the task.\n",
    "\n",
    "**Hint(2):**  \n",
    "\n",
    "Step 1: First, count how many digits\\\n",
    "Step 2: Then, calculate 10 to the power (number of digits - 1).\n",
    "\n",
    "Step 3 with explanation: Say, the input given by the user as in our example, 32768 has 5 digits, so calculating 10 to the power 4 gives us 10000. Then floor dividing 32768 by 10000, we can get 3.\\\n",
    "Proceeding further, the remainder of 32768 by 10000 (32768 % 10000) gives us 2768. This time to get 2 we need to floor divide 2768 by 1000 which is basically our 10000/10. Again, taking remainder of 2768 by 1000 gives us 768 which we then divide by 100 (i.e. 1000/10) and keep on doing this until there are no more digits left (zero).\n",
    "\n",
    "\n",
    "**To summarize and clarify:**\\\n",
    "Loop 1: First, we count digits like our Task 12, say 5 in this case for 32768\\\n",
    "Loop 2: Then, we calculate 10 to the power 4 (5-1), that is 10000.\\\n",
    "Loop 3: Then we keep repeating the three steps of floor dividing, modulus and dividing by 10 as demonstrated below.\n",
    "\n",
    "32768 // 10000 = 3\\\n",
    "32768 % 10000 = 2768 \\\n",
    "10000 // 10 = 1000\n",
    "\n",
    "2768 // 1000 = 2\\\n",
    "2768 % 1000 = 768\\\n",
    "1000 // 10 = 100\n",
    "\n",
    "768 // 100 = 7\\\n",
    "768 % 100 = 68 \\\n",
    "100 // 10 = 10\n",
    "\n",
    "68 // 10 = 6\\\n",
    "68 % 10 = 8 \\\n",
    "10 // 10 = 1\n",
    "\n",
    "8 // 1 = 8\\\n",
    "8 % 1 = 0 \\\n",
    "1 // 10 = 0\n",
    "\n",
    "Done. Loop ends as number has become 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "IgqcBx8eSK54"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 32768\n",
      "3, 2, 7, 6, 8"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "value=0\n",
    "\n",
    "counter=0\n",
    "\n",
    "input_number=int(input(\"Enter a number: \"))\n",
    "\n",
    "temp=input_number\n",
    "\n",
    "while temp>0:\n",
    "    \n",
    "    temp=temp//10\n",
    "    \n",
    "    counter+=1\n",
    "    \n",
    "power=pow(10,counter-1)\n",
    "\n",
    "while input_number>0:\n",
    "    value=input_number//power\n",
    "    \n",
    "    if input_number<10:\n",
    "        print(value,end=\"\")\n",
    "        \n",
    "    else:\n",
    "        print(value,end=\", \")\n",
    "        \n",
    "    input_number=input_number%power\n",
    "    power=power//10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fTbwwo3mSK6A"
   },
   "source": [
    "### Task 14\n",
    "\n",
    "Write a Python program that takes a number as input from the user and prints the divisors of that number as well as how many divisors the number has.\n",
    "<font color='red'>[The input number has to be an INTEGER]</font>\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:** \n",
    "\n",
    "**Input:**\\\n",
    "6\n",
    "\n",
    "**Output:**\\\n",
    "1, 2, 3, 6 \\\n",
    "Total 4 divisors.\n",
    "\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 02:** \n",
    "\n",
    "**Input:**\\\n",
    "121\n",
    "\n",
    "**Output:**\\\n",
    "1, 11, 121 \\\n",
    "Total 3 divisors.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "aFSd6sYXSK6A"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 6\n",
      "1, 2, 3, 6\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "counter=0\n",
    "\n",
    "input_number=int(input(\"Enter a number: \"))\n",
    "\n",
    "for i in range(1,input_number+1):\n",
    "    \n",
    "    if(i==input_number):\n",
    "        print(i,end=\"\")\n",
    "        \n",
    "        counter+=1\n",
    "        \n",
    "    elif input_number%i==0:\n",
    "        \n",
    "        print(i,end=\", \")\n",
    "              \n",
    "        counter+=1 \n",
    "        \n",
    "print(\"\")\n",
    "\n",
    "print(counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "swvpit_vSK6E"
   },
   "source": [
    "### Task 15\n",
    "Write a Python program that takes a number and tells if it is a perfect number or not. <font color='red'>[The input number has to be an INTEGER]</font>\n",
    "\n",
    "**Perfect Number:** An integer number is said to be a perfect number if its factors, including 1 but not the number itself, sum to the number.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:** \n",
    "\n",
    "**Input:**\\\n",
    "6\n",
    "\n",
    "**Output:**\\\n",
    "6 is a perfect number\n",
    "\n",
    "**Explanation:**\\\n",
    "6 has 4 divisors: 1, 2, 3, and 6. \\\n",
    "If we add all factors except 6 itself, 1 + 2 + 3 = 6. The sum of the factors excluding the number itself sum up to the number therefore \"6 is a perfect number\" is printed.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "\n",
    "**Example 02:** \n",
    "\n",
    "**Input:**\\\n",
    "28\n",
    "\n",
    "**Output:**\\\n",
    "28 is a perfect number\n",
    "\n",
    "**Explanation:**\\\n",
    "28 has divisors: 1, 2, 4, 7, 14, and 28. \\\n",
    "If we add all factors except itself we get 28, 1 + 2 + 4 + 7 + 14 = 28.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example0 3:** \n",
    "\n",
    "**Input:**\\\n",
    "33\n",
    "\n",
    "**Output:**\\\n",
    "33 is not a perfect number\n",
    "\n",
    "**Explanation:**\\\n",
    "33 has 3 divisors: 1, 3, 11, and 33. \\\n",
    "If we add all factors except itself, 15 = 1 + 3 + 11. Sum not equal to the number, therefore 33 is not a perfect number.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "WxrTdQ67SK6E"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number:6\n",
      "6 is a perfect number\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "accumulation=0\n",
    "\n",
    "input_number=int(input(\"Enter a number:\" ))\n",
    "for i in range(1,input_number):\n",
    "              \n",
    "    if input_number%i==0:\n",
    "        \n",
    "        accumulation+=i\n",
    "              \n",
    "if accumulation==input_number:\n",
    "    print(input_number,\"is a perfect number\")\n",
    "              \n",
    "else:\n",
    "    print(input_number,\"is not a perfect number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JunF6mTuSK6H"
   },
   "source": [
    "### Task 16\n",
    "\n",
    "Write a Python program that asks the user for one number and tells if it is a prime number or not. <font color='red'>[The input number has to be an INTEGER]</font>\n",
    "\n",
    "**Prime Number:** If a number has only two divisors, (1 and itself), then it is prime. If it is divisible by more numbers, then it is not a prime.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Hint:** You may use the code for counting divisors from Task 14. \n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:** \n",
    "\n",
    "**Input:**\\\n",
    "11\n",
    "\n",
    "**Output:**\\\n",
    "11 is a prime number\n",
    "\n",
    "**Explanation:**\\\n",
    "11 has only 2 divisors: 1 and 11.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 02:** \n",
    "\n",
    "**Input:**\\\n",
    "6\n",
    "\n",
    "**Output:**\\\n",
    "6 is not a prime number\n",
    "\n",
    "**Explanation:**\\\n",
    "6 has 4 divisors: 1, 2, 3 and 6.\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "s_UhmEARSK6I"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 11\n",
      "11 is a prime number\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "count=0\n",
    "\n",
    "input_number=int(input(\"Enter a number: \"))\n",
    "\n",
    "for i in range(1,input_number+1):\n",
    "    \n",
    "    if input_number%i==0:\n",
    "        count+=1\n",
    "        \n",
    "if count==2:\n",
    "    print(input_number,\"is a prime number\")\n",
    "    \n",
    "else:\n",
    "    print(input_number,\"is not a prime number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2LrNlU1XSK6L"
   },
   "source": [
    "### Task 17\n",
    "\n",
    "Write a Python program that asks the user for a quantity, then takes that many numbers as input and prints the maximum, minimum and average of those numbers. \n",
    "\n",
    "<font color='red'>[Please note that you CANNOT use max, min built-in functions]\n",
    "\n",
    "[Also, you DO NOT need to use lists for this task]</font>\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:** If the user enters 5 as an input for quantity and the enters the 5 numbers, 10, 4, -1, -100, and 1. \\\n",
    "The output of your program should be: “Maximum 10”, “Minimum -100”, “Average is -17.2” as shown below.\n",
    "\n",
    "**Input:**\\\n",
    "5\n",
    "10\n",
    "4\n",
    "-1\n",
    "-100\n",
    "1\n",
    "\n",
    "**Output:**\\\n",
    "Maximum 10\\\n",
    "Minimum -100\\\n",
    "Average is -17.2\n",
    "\n",
    "**Explanation:**\\\n",
    "Average calculation: (10 + 4 + (-1) + (-100) + 1)/5 = -86/5 = -17.2\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "TK68v25sSK6L"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the quantity: 5\n",
      "Enter a number: 10\n",
      "Enter a number: 4\n",
      "Enter a number: -1\n",
      "Enter a number: -100\n",
      "Enter a number: 1\n",
      "Maximum 10\n",
      "Minimum -100\n",
      "Average is -17.2\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "\n",
    "temp=int(input(\"Enter the quantity: \"))\n",
    "\n",
    "max_value=-99999\n",
    "\n",
    "min_value=99999\n",
    "\n",
    "accumulation=0\n",
    "\n",
    "avg_value=0\n",
    "\n",
    "for i in range(temp):\n",
    "    input_number=int(input(\"Enter a number: \"))\n",
    "    \n",
    "    if input_number>max_value:\n",
    "        max_value=input_number\n",
    "        \n",
    "    if input_number<min_value:\n",
    "        min_value=input_number\n",
    "    accumulation=accumulation+input_number\n",
    "    \n",
    "avg_value=accumulation/temp\n",
    "\n",
    "print(\"Maximum\",max_value)\n",
    "print(\"Minimum\",min_value)\n",
    "print(\"Average is\",avg_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QLXvNSiOxhlI"
   },
   "source": [
    "## Task 18\n",
    "\n",
    "Write a python program that prints a square of size N using + where N will be given as input as illustrated in the examples below.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:**\n",
    "\n",
    "**Sample Input**\n",
    "\n",
    "5\n",
    "\n",
    "**Sample Output**<br>\n",
    "+++++<br>\n",
    "+++++<br>\n",
    "+++++<br>\n",
    "+++++<br>\n",
    "+++++<br>\n",
    "\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 02:**\n",
    "\n",
    "**Sample Input**\n",
    "\n",
    "3\n",
    "\n",
    "**Sample Output**<br>\n",
    "+++<br>\n",
    "+++<br>\n",
    "+++<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "nuU0BJmQwsSa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 5\n",
      "*****\n",
      "*****\n",
      "*****\n",
      "*****\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "input_number=int(input(\"Enter a number: \"))\n",
    "\n",
    "for row in range(1,input_number+1):\n",
    "    \n",
    "    for column in range(1,input_number+1):\n",
    "        \n",
    "        print(\"*\",end=\"\")\n",
    "    \n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9tK1-MjFwqM-"
   },
   "source": [
    "### Task 19\n",
    "\n",
    "Write a python program that prints a rectangle of size M (height/line numbers) and N(length/column numbers) using incrementing numbers where M and N will be given as input. Please look it the examples below for clarification.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:**\n",
    "\n",
    "**Sample Input:**\\\n",
    "4\\\n",
    "6\n",
    "\n",
    "**Sample Output:**<br>\n",
    "123456<br>\n",
    "123456<br>\n",
    "123456<br>\n",
    "123456<br>\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 02:**\n",
    "\n",
    "**Sample Input:**\\\n",
    "3\\\n",
    "2\n",
    "\n",
    "**Sample Output:**<br>\n",
    "12<br>\n",
    "12<br>\n",
    "12<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "KcyhD8gNxYdi"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter value of height/no. of lines/row: 3\n",
      "Enter value of column numbers: 2\n",
      "12\n",
      "12\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "\n",
    "M=int(input(\"Enter value of height/no. of lines/row: \"))\n",
    "\n",
    "N=int(input(\"Enter value of column numbers: \"))\n",
    "\n",
    "for height in range(1,M+1):\n",
    "    \n",
    "    for length in range(1,N+1):\n",
    "        \n",
    "        print(length,end= \"\")\n",
    "              \n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ReUpRcLuw0_b"
   },
   "source": [
    "### Task 20\n",
    "\n",
    "Write a python program that prints a right angled triangle of height N using incrementing numbers where N will be given as input.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:**\n",
    "\n",
    "**Sample Input:**\\\n",
    "4\n",
    "\n",
    "**Sample Output:**<br>\n",
    "1<br>\n",
    "12<br>\n",
    "123<br>\n",
    "1234<br>\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 02:**\n",
    "\n",
    "**Sample Input:**\\\n",
    "5\n",
    "\n",
    "**Sample Output:**<br>\n",
    "1<br>\n",
    "12<br>\n",
    "123<br>\n",
    "1234<br>\n",
    "12345<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "UtqBxocnxai9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter value of height: 4\n",
      "1\n",
      "12\n",
      "123\n",
      "1234\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "\n",
    "N=int(input(\"Enter value of height: \"))\n",
    "\n",
    "for row in range(1,N+1):\n",
    "    \n",
    "    for column in range(1,row+1):\n",
    "        \n",
    "        print(column,end=\"\")\n",
    "        \n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AWbbbs5mSK6O"
   },
   "source": [
    "## Optional Tasks (21 -26) [Ungraded]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HHaloARnTY9O"
   },
   "source": [
    "**These tasks are just for practice. No marks will be deducted for not completing them and no extra marks will be given for solving them. Just try and practice these advanced problems.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a0SjEWlsw6Vt"
   },
   "source": [
    "### Task 21\n",
    "\n",
    "Write a python program that prints all the fibonacci numbers from 0 to N where N will be given as input by the user. \n",
    "\n",
    "**A Fibonacci number is a number which is the summation of its previous two fibonacci numbers.**\n",
    "\n",
    "First two fibonacci numbers are 0 and 1. \n",
    "\n",
    "So the 3rd is 0 + 1 = 1, \n",
    "\n",
    "the 4th is 1 + 1 = 2, \n",
    "\n",
    "the 5th is 1 + 2 = 3,\n",
    "\n",
    "the 6th one is 2 + 3 = 5,\n",
    "\n",
    "and so on. \n",
    "\n",
    "i.e. 0, 1, 1, 2, 3, 5, 8, 13, 21.......\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:**\n",
    "\n",
    "**Sample Input:**<br>\n",
    "10\n",
    "\n",
    "**Sample Output:**<br>\n",
    "0 1 1 2 3 5 8\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 02:**\n",
    "\n",
    "**Sample Input:**<br>\n",
    "15\n",
    "\n",
    "**Sample Output:**<br>\n",
    "0 1 1 2 3 5 8 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vQhQFFBWx-h0"
   },
   "outputs": [],
   "source": [
    "#Todo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bByH1fWsw7av"
   },
   "source": [
    "### Task 22\n",
    "\n",
    "Write a python program that converts a Decimal Integer number to a Binary Number. \n",
    "\n",
    "**A decimal can be converted to a binary number by keeping track of the remainders after each division of that number by 2. **\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:**\n",
    "\n",
    "For example, to convert 11 to a binary number, we can try the following approach.\n",
    "\n",
    "11/2 = 5 (Remainder 1) \n",
    "<br>5/2 = 2 (Remainder 1) \n",
    "<br>2/2 = 1 (Remainder 0) \n",
    "<br>1/2 = 0 (Remainder 1) \n",
    "\n",
    "Now, taking the remainders from bottom to top gives us the binary number which is 1011. Binary of 11 is 1011.\n",
    "\n",
    "**Sample Input:** <br>\n",
    "11\n",
    "\n",
    "**Sample Output:**<br>\n",
    "1011\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 02:**\n",
    "\n",
    "Similarly, to convert 13 to a binary number:\n",
    "\n",
    "13/2 = 6 (Remainder 1) \n",
    "<br>6/2 = 3 (Remainder 0) \n",
    "<br>3/2 = 1 (Remainder 1) \n",
    "<br>1/2 = 0 (Remainder 1) \n",
    "\n",
    "Again, taking the remainders from the bottom to top, which is 1101 gives us the binary number. Binary of 13 is 1101.\n",
    "\n",
    "**Sample Input:** <br>\n",
    "13\n",
    "\n",
    "**Sample Output:**<br>\n",
    "1101"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AEXGx3skyBha"
   },
   "outputs": [],
   "source": [
    "#Todo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "g_aR1Ozgw_rr"
   },
   "source": [
    "### Task 23\n",
    "\n",
    "Write a python program that converts a Binary number to a Decimal Integer Number after taking the binary number as an input from the user. \n",
    "\n",
    "**A binary number can be converted to its corresponding decimal number by multiplying each binary digit with a power of 2 where the power denotes the position of the binary digit**\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 01:**\n",
    "\n",
    "For example, to convert 1010 to decimal, we can do this\n",
    "\n",
    "\n",
    "$2^{3}$ x 1 + $2^{2}$ x 0 + $2^{1}$ x 1 + $2^{0}$ x 0 = 10\n",
    "\n",
    "\n",
    "**Sample Input:** <br>\n",
    "1010\n",
    "\n",
    "**Sample Output:** <br>\n",
    "10\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 02:**\n",
    "\n",
    "So, to convert 11101, we can do this\n",
    "\n",
    "\n",
    "$2^{4}$ x 1 + $2^{3}$ x 1 + $2^{2}$ x 1 + $2^{1}$ x 0 + $2^{0}$ x 1 = 29\n",
    "\n",
    "\n",
    "**Sample Input:** <br>\n",
    "11101\n",
    "\n",
    "**Sample Output:** <br>\n",
    "29"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZZmhMI6VyCky"
   },
   "outputs": [],
   "source": [
    "#Todo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1Ef3zxQsSK6Y"
   },
   "source": [
    "### Task 24\n",
    "Write a Python program that asks the user for a range (a starting number and an ending number) and then \n",
    "**counts** how many numbers are prime numbers and how many numbers are perfect numbers between that range. It also **prints** those numbers in the format shown in the output of the example given below. \n",
    "\n",
    "\n",
    "=========================================================================\n",
    "\n",
    "**Hint (1):** We may declare two strings/lists to store the prime and perfect numbers. Inside the loop, we check for prime and perfect numbers and add them to respective string/list besides counting them.\n",
    "\n",
    "**Hint (2):** We may need to convert numbers in String to integers for checking and calculations. We may again need to convert numbers to Strings for storing and printing as the outputs shown in the example below.\n",
    "\n",
    "=========================================================================\n",
    "\n",
    "**Example:** If the user gives us a range of between 2 and 6, there are 3 prime numbers (2, 3, 5) and 1 perfect number (6) in that range. \n",
    "\n",
    "**Input:**\\\n",
    "2\\\n",
    "6\n",
    "\n",
    "**Output:**\\\n",
    "Between 2 and 6,\\\n",
    "Found 3 prime numbers \\\n",
    "Found 1 perfect number\\\n",
    "Prime numbers: 2,  3,  5 \\\n",
    "Perfect number: 6 \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_YU9xdPBSK6Y"
   },
   "outputs": [],
   "source": [
    "#Todo\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "CSE110 Lab Assignment 2.ipynb",
   "provenance": []
  },
  "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}