CSE110_Lab_Assignment_02_(Loops).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4wbfWEkOSK4T"
   },
   "source": [
    "# CSE110 Assignment 2 (Loops)\n",
    "\n",
    "This assignment is to guide in solving basic programming problems using loop in Python. \n",
    "\n",
    "**<font color='red'>[Please follow variable naming conventions including using meaningful variable names for all the tasks]</font>**\\\n",
    "<font color='red'>When you run your code, please make sure your outputs exactly match the sample outputs for each of the sample inputs given. Check if your code works for other valid inputs not given in the samples.</font>\n",
    "\n",
    "## Write the Python code for the following problems:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TUld3qrMgsFR"
   },
   "outputs": [],
   "source": [
    "#Write your name, student ID and theory section number below:\n",
    "#Student Name: MD. Shafiur Rahman\n",
    "#Student ID: 21201613\n",
    "#CSE110 Theory Section No: 38"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w269kMywSK4V"
   },
   "source": [
    "### Task 1\n",
    "\n",
    "Write the python programs, 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",
    "**Hint(1):** You may use a while loop for solving these problems.\n",
    "\n",
    "**Hint(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 may be initialized at 24 and then 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 for the given sequence here.\n",
    "\n",
    "For your understanding, the code for Task 1(a) is done for you.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "H9nuTYCuSK4X",
    "outputId": "e176576c-ca70-427d-ec88-9ec78f02a1a3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24, 18, 12, 6, 0, -6"
     ]
    }
   ],
   "source": [
    "# a) 24, 18, 12, 6, 0, -6\n",
    "\n",
    "# initializing 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": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YWLB_TuLSK4h",
    "outputId": "e4f65714-441a-48be-d0fa-2bd369b890bf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10, -5, 0, 5, 10, 15, 20"
     ]
    }
   ],
   "source": [
    "# b)-10, -5, 0, 5, 10, 15, 20\n",
    "# write your code here\n",
    "counter = -10\n",
    "\n",
    "while counter <= 20:\n",
    "   \n",
    "    if counter == 20:\n",
    "        print(counter, end = \"\") \n",
    "    else:\n",
    "        print(counter, end = \", \") \n",
    "     \n",
    "    counter = counter + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "b5blHg8zSK4n",
    "outputId": "4473903b-299b-4b62-8c78-03e8d1075a1e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18, 27, 36, 45, 54, 63"
     ]
    }
   ],
   "source": [
    "# c)18, 27, 36, 45, 54, 63\n",
    "# write your code here\n",
    "counter = 18\n",
    "\n",
    "while counter <= 63:  \n",
    "    \n",
    "    if counter == 63:\n",
    "        print(counter, end = \"\") \n",
    "    else:\n",
    "        print(counter, end = \", \") \n",
    "     \n",
    "    counter = counter + 9 "
   ]
  },
  {
   "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": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "lA6BDPaaSK4v",
    "outputId": "12797441-4def-4074-c376-6bddb768fcac"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18, -27, 36, -45, 54, -63"
     ]
    }
   ],
   "source": [
    "# d)18,-27, 36,-45,54,-63\n",
    "# write your code here\n",
    "counter = 18\n",
    "\n",
    "while counter <= 63:\n",
    "\n",
    "    if counter == 63:\n",
    "        print(\"-\"+str(counter), end = \"\")\n",
    "    else:\n",
    "        if counter % 2 == 0: \n",
    "           print(counter, end = \", \")\n",
    "        else:\n",
    "           print(\"-\"+str(counter), end = \", \")\n",
    "     \n",
    "    counter = counter + 9"
   ]
  },
  {
   "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 1:** If the user enters “Toyota” and 2, your program should print the name “Toyota” two times.\n",
    "\n",
    "**Sample Input 1:**\\\n",
    "Toyota\\\n",
    "2\n",
    "\n",
    "**Sample Output 1:**\\\n",
    "Toyota\\\n",
    "Toyota\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 2:** If the user enters “Veyron” and 5, your program should print the name “Veyron” five times.\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "Veyron\\\n",
    "5\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "Veyron\\\n",
    "Veyron\\\n",
    "Veyron\\\n",
    "Veyron\\\n",
    "Veyron\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "u5yX33mvSK45",
    "outputId": "7622b8d0-9fb9-483d-c6c6-a3f00b8ce540"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a car name: Veyron\n",
      "Enter a number: 5\n",
      "Veyron\n",
      "Veyron\n",
      "Veyron\n",
      "Veyron\n",
      "Veyron\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "car = input(\"Enter a car name: \")\n",
    "num = int(input(\"Enter a number: \"))\n",
    "\n",
    "for i in range (num):\n",
    "    print(car)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xT0l0U35SK5A"
   },
   "source": [
    "### Task 3\n",
    "Write the Python code of a program that adds all numbers that are multiples of **both 7 and 9** up to 600 (including 600) i.e. 63, 126, 189, 252, ....\n",
    "\n",
    "**The output of your program should be:** 2835\\\n",
    "since 63 + 126 + 189 + 252 + 315 + 378 + 441 + 504 + 567 = 2835\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Q6dix8WhSK5B",
    "outputId": "5676fe39-b40f-44c5-abfa-e66569026a88"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2835\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "counter = 1\n",
    "sum = 0\n",
    "while counter <= 600:\n",
    "    if counter % 7 == 0 and counter % 9 ==0:\n",
    "        sum = sum + counter\n",
    "    counter += 1\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8swUoCy9SK5F"
   },
   "source": [
    "### Task 4\n",
    "Write the Python code of a program that adds all numbers that are multiples of **either 7 or 9** up to 600 (including 600) i.e. 7, 9, 14, 18, 21, 27, 28, 35, 36..... \\\n",
    "Ensure that numbers like 63, 126, 189 which are multiples of both 7 and 9 are added only once in the sum.\n",
    "\n",
    "**The output of your program should be:** 42649\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "pbIA-waFSK5G",
    "outputId": "e53b965f-a276-4cd2-fd23-85ee9eaad3c2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42649\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "counter = 1\n",
    "sum = 0\n",
    "while counter <= 600:\n",
    "    if counter % 7 == 0 or counter % 9 ==0:\n",
    "        sum = sum + counter\n",
    "    counter += 1\n",
    "print(sum)"
   ]
  },
  {
   "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) i.e. 7, 9, 14, 18, 21..... and so on but not the numbers 63, 126, 189..... which are multiples of both 7 and 9.\n",
    "\n",
    "**The output of your program should be:** 39814\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LiAvUr1QSK5M",
    "outputId": "259ec74b-0a0b-48c3-e7ca-545bfe9883e4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39814\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "counter = 1\n",
    "sum = 0\n",
    "while counter <= 600:\n",
    "    if counter % 7 == 0 and counter % 9 ==0:\n",
    "        counter += 1\n",
    "        pass\n",
    "    elif counter % 7 == 0 or counter % 9 ==0:\n",
    "        sum = sum + counter\n",
    "    counter += 1\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8SmvPvfaSK5P"
   },
   "source": [
    "### Task 6\n",
    "Write the Python code of a program that displays all the **odd numbers** between 10 and 50 (inclusive).\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": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "PJmT9fvuSK5Q",
    "outputId": "0fbb3a95-ad84-42c9-9ded-0a07eb0bf3a7"
   },
   "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 \n",
      "11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 "
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "# While loop\n",
    "counter = 10\n",
    "while (counter <= 50):\n",
    "    if counter % 2 != 0:\n",
    "        print (counter, end=\" \")\n",
    "    counter += 1\n",
    "    \n",
    "print()\n",
    "# For loop\n",
    "for x in range(11,50,2):\n",
    "    print(x, end=\" \")"
   ]
  },
  {
   "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",
    "**Sample Input 1:**\\\n",
    "5\n",
    "\n",
    "**Sample Output 1:**\\\n",
    "15\n",
    "\n",
    "**Explanation:** y = 1 - 4 + 9 - 16 + 25 = 15\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "10\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "-55\n",
    "\n",
    "**Explanation:** y = 1 - 4 + 9 - 16 + 25 - 36 + 49 - 64 + 81 - 100 = -55\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 3:**\\\n",
    "20\n",
    "\n",
    "**Sample Output 3:**\\\n",
    "-210\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BbJe-7AuSK5V",
    "outputId": "f4011fac-bdbb-48f2-e900-517d9e1802ff"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 20\n",
      "-210\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "num = int(input(\"Enter a number: \"))\n",
    "counter = 1\n",
    "sum = 0\n",
    "while counter <= num:\n",
    "    if counter % 2 == 0:\n",
    "        sum = sum - counter**2\n",
    "    else:\n",
    "        sum = sum + counter**2\n",
    "    counter += 1\n",
    "print(sum)"
   ]
  },
  {
   "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 and then display the total and the average of **ONLY** the **odd numbers** among those ten numbers.\\\n",
    "<font color='red'>[Please do not use list for this task]</font>\n",
    "\n",
    "==========================================================\n",
    "\n",
    "\n",
    "**Sample Input 1:**\\\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",
    "**Sample Output 1:**\n",
    "The total of the odd numbers is 25 and their average is 5.0\n",
    "\n",
    "\n",
    "**Explanation:** The total is 1 + 3 + 5 + 7 + 9 = 25 and the average is 25/5 = 5.0\n",
    "\n",
    "==========================================================\n",
    "\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "-20\n",
    "\n",
    "13\n",
    "\n",
    "-5\n",
    "\n",
    "40\n",
    "\n",
    "-17\n",
    "\n",
    "10\n",
    "\n",
    "20\n",
    "\n",
    "-8\n",
    "\n",
    "99\n",
    "  \n",
    "-200\n",
    "\n",
    "**Sample Output 2:**\n",
    "\n",
    "The total of the odd numbers is 90 and their average is 22.5\n",
    "\n",
    "\n",
    "**Explanation:** The total is 90 = 13 + (-5) + (-17) + 99) and their average is 90/4 = 22.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c0akirXXSK5m",
    "outputId": "aeab2055-267a-497d-be8e-2fe019185f38"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: -20\n",
      "Enter a number: 13\n",
      "Enter a number: -5\n",
      "Enter a number: 40\n",
      "Enter a number: -17\n",
      "Enter a number: 10\n",
      "Enter a number: 20\n",
      "Enter a number: -8\n",
      "Enter a number: 99\n",
      "Enter a number: 200\n",
      "The total of the odd numbers is 90 and their average is 22.5\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "sum = 0\n",
    "odd = 0\n",
    "ave = 0\n",
    "\n",
    "for i in range(10):\n",
    "    num = int(input(\"Enter a number: \"))\n",
    "    if num % 2 ==0:\n",
    "        pass\n",
    "    else:\n",
    "        sum = sum + num\n",
    "        odd += 1\n",
    "        \n",
    "ave = sum / odd\n",
    "print(\"The total of the odd numbers is \"+ str(sum) + \" and their average is \" + str(ave))"
   ]
  },
  {
   "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",
    "**Sample Input 1:**\\\n",
    "50\n",
    "\n",
    "**Sample Output 1:**\\\n",
    "196\n",
    "\n",
    "**Explanation:** The summation of multiples of 7 up to 50 is 7 + 14 + 21 + 28 + 35 + 42 + 49 = 196\n",
    "\n",
    "==========================================================\n",
    "\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "75\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "385\n",
    "\n",
    "**Explanation:** The summation of multiples of 7 up to 75 is 7 + 14 + 21 + 28 + 35 + 42 + 49 + 56 + 63 + 70 = 385\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zLsrA8dSSK5t",
    "outputId": "8d95af42-ce7d-40b1-f0ca-26898fe20042"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 75\n",
      "385\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "num = int(input(\"Enter a number: \"))\n",
    "sum = 0\n",
    "count = 1\n",
    "while count <= num:\n",
    "    if count % 7 ==0:\n",
    "        sum = sum + count\n",
    "    count += 1\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OZ9pVIvhSK5w"
   },
   "source": [
    "### Task 10\n",
    "Write a Python code that will read 5 numbers from the user. Your program should 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 5 numbers.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 1:**\\\n",
    "1\\\n",
    "2\\\n",
    "3\\\n",
    "4\\\n",
    "5\n",
    "\n",
    "**Sample Output 1:**\\\n",
    "1\\\n",
    "3\\\n",
    "6\\\n",
    "10\\\n",
    "15\n",
    "\n",
    "**Explanation:**\\\n",
    "When the user enters 1 at first, we print 1, then \\\n",
    "The user enters 2, (1 + 2) = 3, so our output is 3, then \\\n",
    "The user enters 3, (3 + 3) = 6, hence our output is 6, then \\\n",
    "The user enters 4, and we have (6 + 4) = 10, we print 10, and finally\\\n",
    "The user enters 5, the final sum is 15 which is printed as the last output.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "11\\\n",
    "-29\\\n",
    "-3\\\n",
    "47\\\n",
    "50\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "11\\\n",
    "-18\\\n",
    "-21\\\n",
    "26\\\n",
    "76\n",
    "\n",
    "**Explanation:**\\\n",
    "When the user enters 11 at first, we print 11, then \\\n",
    "The user enters -29, (11 + (-29)) = -18, so our output is -18, then \\\n",
    "The user enters -3, (-18 - 3) = -21, hence our output is -21, then \\\n",
    "The user enters 4, and we have (-21 + 47) = 26, we print 26, and finally\\\n",
    "The user enters 50, the final sum is (26 + 50) = 76 which is printed as the last output.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Oozj5K6CUs8F",
    "outputId": "13d0fca6-4932-4aa4-b6c2-08433dc94d65"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 11\n",
      "11\n",
      " -29\n",
      "-18\n",
      " -3\n",
      "-21\n",
      " 47\n",
      "26\n",
      " 50\n",
      "76\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "sum = 0\n",
    "for val in range(0,5):\n",
    "    num = int(input(\" \"))\n",
    "    sum = sum + num\n",
    "    print(sum)"
   ]
  },
  {
   "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": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the numbers: 38762\n",
      "2, 6, 7, 8, 3\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "num = input(\"Enter the numbers: \")\n",
    "number = int(num)\n",
    "\n",
    "while number != 0:\n",
    "    p = number % 10\n",
    "    number = number //10\n",
    "    if number == 0:\n",
    "        print(p)\n",
    "    else:\n",
    "        print(p, end=\", \")\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "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": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 9876\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "num = int(input(\"Enter a number: \"))\n",
    "count = 0\n",
    "while num != 0:\n",
    "    num = num // 10\n",
    "    count += 1\n",
    "    \n",
    "print(count)"
   ]
  },
  {
   "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": 2,
   "metadata": {
    "id": "IgqcBx8eSK54"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 32768\n",
      "3, 2, 7, 6, 8\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "num = int(input(\"Enter a number: \"))\n",
    "x = num\n",
    "count = 0\n",
    "\n",
    "while x != 0:\n",
    "    x = x // 10\n",
    "    count += 1\n",
    "\n",
    "while num != 0:\n",
    "    power = 10 ** (count-1)\n",
    "    p = num // power\n",
    "    num = num % power\n",
    "    count -= 1\n",
    "\n",
    "    if num == 0:\n",
    "        print(p)\n",
    "    else:\n",
    "        print(p, end=\", \")"
   ]
  },
  {
   "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",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 1:**\\\n",
    "6\n",
    "\n",
    "**Sample Output 1:**\\\n",
    "1, 2, 3, 6 \\\n",
    "Total 4 divisors.\n",
    "\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "121\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "1, 11, 121 \\\n",
    "Total 3 divisors.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "aFSd6sYXSK6A",
    "outputId": "f40418a0-30f0-4d93-931c-c5d45f7164a3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 121\n",
      "1, 11, 121\n",
      "Total 3 divisors\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "num = int(input(\"Enter a number: \"))\n",
    "count = 1\n",
    "divisor = 0\n",
    "while count <= num:\n",
    "    if count == num:\n",
    "        print(count)\n",
    "        divisor += 1\n",
    "    elif num % count == 0 :\n",
    "        print(count,end=\", \")\n",
    "        divisor += 1\n",
    "    count += 1\n",
    "    \n",
    "divisor = str(divisor)\n",
    "print(\"Total \" + divisor + \" divisors\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "swvpit_vSK6E"
   },
   "source": [
    "### Task 15\n",
    "Write a Python program that takes a number as input from the user and tells if it is a perfect number or not.\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",
    "**Sample Input 1:**\\\n",
    "6\n",
    "\n",
    "**Sample Output 2:**\\\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",
    "**Sample Input 2:**\\\n",
    "28\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "28 is a perfect number\n",
    "\n",
    "**Explanation:**\\\n",
    "28 has the 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",
    "**Sample Input 3:**\\\n",
    "33\n",
    "\n",
    "**Sample Output 3:**\\\n",
    "33 is not a perfect number\n",
    "\n",
    "**Explanation:**\\\n",
    "33 has 4 divisors: 1, 3, 11, and 33. \\\n",
    "If we add all factors except itself, 15 = 1 + 3 + 11. The sum is not equal to the number, therefore 33 is not a perfect number.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "WxrTdQ67SK6E",
    "outputId": "a6b07408-7a10-4570-816d-afa72f700f60"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 28\n",
      "28 is a perfect number\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "num = int(input(\"Enter a number: \"))\n",
    "count = 1\n",
    "sum = 0\n",
    "\n",
    "while count < num:\n",
    "    if num % count == 0:\n",
    "        sum += count\n",
    "    count += 1\n",
    "if sum == count:\n",
    "    num = str(num)\n",
    "    print(num + \" is a perfect number\")\n",
    "else:\n",
    "    num = str(num)\n",
    "    print(num + \" 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.\n",
    "\n",
    "**Prime Number:** If a number has only two divisors, (1 and itself), then it is a prime number. If it is divisible by more numbers, then it is not a prime.\n",
    "\n",
    "**Hint:** You may use the code for counting divisors from Task 14. \n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 1:**\\\n",
    "11\n",
    "\n",
    "**Sample Output 1:**\\\n",
    "11 is a prime number\n",
    "\n",
    "**Explanation:** 11 has only 2 divisors: 1 and 11.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "6\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "6 is not a prime number\n",
    "\n",
    "**Explanation:** 6 has 4 divisors: 1, 2, 3 and 6.\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "s_UhmEARSK6I",
    "outputId": "0f34504c-2c50-4107-f5a1-787c46755f04"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 11\n",
      "11 is a prime number\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "num= int(input(\"Enter a number: \"))\n",
    "count = 0\n",
    "div = 0\n",
    "\n",
    "if num >= 2:\n",
    "    for i in range(1,num+1):\n",
    "        div = num % i\n",
    "        if div == 0:\n",
    "            count += 1\n",
    "    if count <=2:\n",
    "        print(str(num) + \" is a prime number\")\n",
    "    else:\n",
    "        print(str(num) + \" is not a prime number\")\n",
    "else:\n",
    "    print(str(num) + \" 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:** 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:** Average calculation: (10 + 4 + (-1) + (-100) + 1)/5 = -86/5 = -17.2\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "id": "TK68v25sSK6L"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a quantity: 5\n",
      "10\n",
      "4\n",
      "-1\n",
      "-100\n",
      "1\n",
      "Maximum:  10\n",
      "Minuimum:  -100\n",
      "Average:  -17.2\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "count = int(input(\"Enter a quantity: \"))\n",
    "maximum = 0\n",
    "minimum = 0\n",
    "total = 0\n",
    "for i in range(count):\n",
    "    num = int(input())\n",
    "    \n",
    "    if num > maximum:\n",
    "        maximum = num    \n",
    "    if num < minimum:\n",
    "        minimum = num\n",
    "        \n",
    "    total = total + num\n",
    "    average = total / count\n",
    "    \n",
    "print(\"Maximum: \", maximum)\n",
    "print(\"Minuimum: \", minimum)\n",
    "print(\"Average: \", average)"
   ]
  },
  {
   "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",
    "**Hint:** You may need to use nested loops to solve this problem.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 1:**\n",
    "\n",
    "5\n",
    "\n",
    "**Sample Output 1:**<br>\n",
    "+++++<br>\n",
    "+++++<br>\n",
    "+++++<br>\n",
    "+++++<br>\n",
    "+++++<br>\n",
    "\n",
    "**Explanation:** Here, we may see it as 5 rows and 5 columns, where in each horizontal row/line, 5 '+' is printed next to each other and we have a total of 5 lines.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 2:**\n",
    "\n",
    "3\n",
    "\n",
    "**Sample Output 2:**<br>\n",
    "+++<br>\n",
    "+++<br>\n",
    "+++<br>\n",
    "\n",
    "**Explanation:** If the input is 3, then there will be 3 rows and 3 columns, where in each horizontal row/line, '+' is printed 3 times, 1 in each of the 3 columns and we will have a total of 3 lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nuU0BJmQwsSa",
    "outputId": "d02a522d-0a59-44e6-821c-1f81403bc46e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 3\n",
      "+++\n",
      "+++\n",
      "+++\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "num = int(input(\"Enter a number: \"))\n",
    "plus = \"+\"\n",
    "sum = plus * num\n",
    "for i in range(num):\n",
    "    print(sum)"
   ]
  },
  {
   "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 at the examples below for clarification.\n",
    "\n",
    "**Hint:** You may need to use nested loops and print the loop counter variable in one of the loops.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 1:**\\\n",
    "4\\\n",
    "6\n",
    "\n",
    "**Sample Output 1:**<br>\n",
    "123456<br>\n",
    "123456<br>\n",
    "123456<br>\n",
    "123456<br>\n",
    "\n",
    "**Explanation:** The user has given 4 rows/lines and 6 columns as input. Therefore, we have 4 lines in our output here and in each line, the column number is printed from 1 through to 6 for the 6 columns.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "3\\\n",
    "2\n",
    "\n",
    "**Sample Output 2:**<br>\n",
    "12<br>\n",
    "12<br>\n",
    "12<br>\n",
    "\n",
    "**Explanation:** Our user input this time is 3 rows/lines and 2 columns. So, our output has 3 lines and in each line, the column number 1 and 2 are printed next to each other as the user only wants 2 columns here.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KcyhD8gNxYdi",
    "outputId": "b73ff461-0d81-4598-bf72-21c975ef6e5a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter column number: 3\n",
      "Enter row number: 2\n",
      "12\n",
      "12\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "column = int(input(\"Enter column number: \"))\n",
    "row = int(input(\"Enter row number: \"))\n",
    "count = 1\n",
    "\n",
    "for i in range (1,column+1):\n",
    "    for j in range(1,row+1):\n",
    "        print(j,end=\"\")\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",
    "**Hint:** You may need to use nested loops. Try to think up to which point should the inner loop run.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 1:**\\\n",
    "4\n",
    "\n",
    "**Sample Output 1:**<br>\n",
    "1<br>\n",
    "12<br>\n",
    "123<br>\n",
    "1234<br>\n",
    "\n",
    "**Explanation:** For an input of 4, we have 4 rows/lines where in each line, the respective column number is printed sequentially up to the line/row number. So, in line number 1, we have 1 only. In line 2, 12 is printed. In line 3, we have 123 and so on.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "5\n",
    "\n",
    "**Sample Output 2:**<br>\n",
    "1<br>\n",
    "12<br>\n",
    "123<br>\n",
    "1234<br>\n",
    "12345<br>\n",
    "\n",
    "**Explanation:** Numbers are printed sequentially up to the line number for each of the lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UtqBxocnxai9",
    "outputId": "12f9dc7f-1935-4337-bb80-d98a5bd7f9e5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 4\n",
      "1\n",
      "12\n",
      "123\n",
      "1234\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "num = int(input(\"Enter a number: \"))\n",
    "count = 1\n",
    "\n",
    "for i in range(1,num+1):\n",
    "    for j in range(1,i+1):\n",
    "        print(j,end=\"\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AWbbbs5mSK6O"
   },
   "source": [
    "## Optional Tasks (21 -25) [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",
    "The 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",
    "**Sample Input 1:**<br>\n",
    "10\n",
    "\n",
    "**Sample Output 1:**<br>\n",
    "0 1 1 2 3 5 8\n",
    "\n",
    "**Explanation**: All fibonacci numbers up to the number 10 is printed separated by spaces.\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Sample Input 2:**<br>\n",
    "15\n",
    "\n",
    "**Sample Output 2:**<br>\n",
    "0 1 1 2 3 5 8 13\n",
    "\n",
    "**Explanation**: All fibonacci numbers up to the number 15 is printed separated by spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "vQhQFFBWx-h0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number: 21\n",
      "0 1 1 2 3 5 8 13 21 "
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "n = int(input(\"Enter number: \"))\n",
    "\n",
    "n1= 0\n",
    "n2= 1  \n",
    "print(n1,end=' ')\n",
    "while n2 <= n:\n",
    "     print(n2,end=' ')\n",
    "     sum = n1 + n2\n",
    "                         \n",
    "     n1 = n2\n",
    "     n2 = sum"
   ]
  },
  {
   "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",
    "*Hint: 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 1:**\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 1:** <br>\n",
    "11\n",
    "\n",
    "**Sample Output 1:**<br>\n",
    "1011\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 2:**\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 2:** <br>\n",
    "13\n",
    "\n",
    "**Sample Output 2:**<br>\n",
    "1101"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "id": "AEXGx3skyBha"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a Decimal Number: 13\n",
      "1101\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "n = int(input(\"Enter a Decimal Number: \"))\n",
    "b = \"\"\n",
    "while n > 0:\n",
    "    b += str(n % 2)\n",
    "    n = n // 2\n",
    "    \n",
    "bin = \"\"\n",
    "for i in b: \n",
    "    bin = i + bin\n",
    "\n",
    "print(int(bin))"
   ]
  },
  {
   "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",
    "**Note: 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 1:**\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 1:** <br>\n",
    "1010\n",
    "\n",
    "**Sample Output 1:** <br>\n",
    "10\n",
    "\n",
    "==========================================================\n",
    "\n",
    "**Example 2:**\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 2:** <br>\n",
    "11101\n",
    "\n",
    "**Sample Output 2:** <br>\n",
    "29"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "ZZmhMI6VyCky"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a Binary Number: 11101\n",
      "29\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "n = input(\"Enter a Binary Number: \")\n",
    "num = int(n) \n",
    "count = 0\n",
    "\n",
    "while num != 0:\n",
    "    num = num // 10\n",
    "    count += 1\n",
    "\n",
    "d = 0\n",
    "for i in n:\n",
    "    d += 2**(count-1) * int(i)\n",
    "    count -= 1\n",
    "    \n",
    "print(d)"
   ]
  },
  {
   "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": 1,
   "metadata": {
    "id": "_YU9xdPBSK6Y"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter starting number: 1\n",
      "Enter ending number: 100\n",
      "Between 1 and 100,\n",
      "Found 26 prime numbers\n",
      "Found 2 perfect number\n",
      "Prime numbers: 1, 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",
      "Perfect number: 6, 28\n"
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "n1=int(input(\"Enter starting number: \"))\n",
    "n2=int(input(\"Enter ending number: \"))\n",
    "\n",
    "prime = \"\"\n",
    "perfect = \"\"\n",
    "\n",
    "p1 = 0\n",
    "p2 = 0\n",
    "\n",
    "for i in range(n1,n2+1):\n",
    "    count=0\n",
    "    if i >= 2:\n",
    "        for j in range(1,i+1):\n",
    "            div = i % j\n",
    "            if div == 0:\n",
    "                count += 1\n",
    "    if count <=2:\n",
    "        if prime == \"\":\n",
    "            prime += str(i)\n",
    "        else:\n",
    "            prime += \", \" + str(i)\n",
    "        p1 += 1\n",
    "\n",
    "    else:\n",
    "        pass\n",
    "\n",
    "for x in range(n1,n2+1):\n",
    "    sum=0\n",
    "    for i in range(1,x):\n",
    "        if x % i == 0:\n",
    "            sum += i\n",
    "    if sum == x:\n",
    "        if perfect == \"\":\n",
    "            perfect += str(sum)\n",
    "        else:\n",
    "            perfect += \", \" + str(sum)\n",
    "        p2 += 1\n",
    "    else:\n",
    "        pass\n",
    "\n",
    "print(f\"Between {n1} and {n2},\")\n",
    "print(f\"Found {p1} prime numbers\")\n",
    "print(f\"Found {p2} perfect number\")\n",
    "print(f\"Prime numbers: {prime}\")\n",
    "print(f\"Perfect number: {perfect}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6aQWKTPdhmNi"
   },
   "source": [
    "###Task 25\n",
    "\n",
    "Write a python program that asks the user for a range, a starting number(inclusive) and an ending number (inclusive). Then, take another input to for checking. If the product of all the digits of each number in the range is divisible by the third input, then print the number.\n",
    "\n",
    "=========================================================================\n",
    "\n",
    "**Sample Input 1:**\\\n",
    "25\\\n",
    "30\\\n",
    "4 \n",
    "\n",
    "**Sample Output 1:**\\\n",
    "12 16 0\n",
    "\n",
    "**Explanation:** The product of all the digits of each number from 25 to 30 are 2 x 5, 2 x 6, 2 x 7, 2 x 8, 2 x 9 and 3 x 0. The final products are 10, 12, 14, 16, 18 and 0 respectively. Out of these numbers only 12, 16 and 0 are divisible by the third input 4 and therefore they are printed.\n",
    "\n",
    "=========================================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "351\\\n",
    "356\\\n",
    "9\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "45 90\n",
    "\n",
    "**Explanation:** The product of all the digits of each number from 351 to 356 are 3x5x1, 3x5x2, 3x5x3, 3x5x4, 3x5x5 and 3x5x6. The final products are 15, 30, 45, 60, 75 and 90 respectively. Out of these numbers only 45 and 90 are divisible by 9 and therefore they are printed.\n",
    "\n",
    "=========================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the starting number: 25\n",
      "Enter the ending number: 30\n",
      "Enter the divisor: 4\n",
      "12 16 0 "
     ]
    }
   ],
   "source": [
    "#Todo\n",
    "n1 = int(input(\"Enter the starting number: \"))\n",
    "n2 = int(input(\"Enter the ending number: \"))\n",
    "num = int(input(\"Enter the divisor: \"))\n",
    "\n",
    "for i in range(n1,n2+1):\n",
    "    product = 1\n",
    "    n = i\n",
    "    while n > 0:\n",
    "        digit = n % 10\n",
    "        product *= digit\n",
    "        n //= 10\n",
    "    if product % divisor == 0:\n",
    "        print(product, end=\" \")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "21201613_MD. Shafiur Rahman_38_CSE110Assignment2.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
}