Assignment_3_(Loops)_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMHwnZ/dIrwNGFXk5ychqjL",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/azaynul10/Assignments-Of-Programming-Language-1/blob/main/Assignment_3_(Loops)_.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Task 1\n",
        "Write the python programs, which prints the following sequences of values in loops:\n",
        "\n",
        "a) 24, 18, 12, 6, 0, -6\n",
        "\n",
        "\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",
        "\n",
        "print(1)\n",
        "\n",
        "print(2)\n",
        "\n",
        "Output:\n",
        "\n",
        "1\n",
        "\n",
        "2\n",
        "\n",
        "\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",
        "\n",
        "print(1, end =\"\")\n",
        "\n",
        "print(2)\n",
        "\n",
        "Output: (prints the next output right to the previous one)\n",
        "\n",
        "12\n",
        "\n",
        "\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"
      ],
      "metadata": {
        "id": "7qgginOI4Nt5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Task 16\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",
        "[Please note that you CANNOT use max, min built-in functions]\n",
        "[Also, you DO NOT need to use lists for this task]\n",
        "\n",
        "\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",
        "Input:\n",
        "5 \n",
        "10 \n",
        "4 \n",
        "-1 \n",
        "-100 \n",
        "1\n",
        "Output:\n",
        "Maximum 10\n",
        "Minimum -100\n",
        "Average is -17.2\n",
        "Explanation: Average calculation: (10 + 4 + (-1) + (-100) + 1)/5 = -86/5 = -17.2\n"
      ],
      "metadata": {
        "id": "c0NLmE2JHqjQ"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LdG4hp0zOhaP",
        "outputId": "fc0bf07f-7f26-464d-b922-834351f19bb0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "24, 18, 12, 6, 0, -6"
          ]
        }
      ],
      "source": [
        "#Task1a\n",
        "counter=24\n",
        "while counter>=-6:\n",
        "  if counter==-6:\n",
        "    print(counter, end=\"\")\n",
        "  else:\n",
        "    print(counter, end=\", \")\n",
        "  counter=counter-6   "
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write the python programs, which prints the following sequences of values in loops:\n",
        "\n",
        "b) -10, -5, 0, 5, 10, 15, 20"
      ],
      "metadata": {
        "id": "jqq9-V674zNV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task1b\n",
        "counter=-10\n",
        "while counter<=20:\n",
        "  if counter==20:\n",
        "    print(counter, end=\"\")\n",
        "  else:\n",
        "    print(counter, end=\", \")\n",
        "  counter+=5    "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "baul2ROFQzRA",
        "outputId": "20811e35-5e82-49c4-b6b6-d9ddd8074c63"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-10, -5, 0, 5, 10, 15, 20"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write the python programs, which prints the following sequences of values in loops:\n",
        "\n",
        "c) 18, 27, 36, 45, 54, 63"
      ],
      "metadata": {
        "id": "K__3u1gM5DdE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task1c\n",
        "counter=18\n",
        "while counter<=63:\n",
        "  if counter==63:\n",
        "    print(counter, end=\"\")\n",
        "  else:\n",
        "    print(counter, end=\", \")\n",
        "  counter=counter+9   "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iowYiA5aSTDc",
        "outputId": "fe7feb1f-6d79-49d2-d4e4-e34f02e0fd9e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "18, 27, 36, 45, 54, 63"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write the python programs, which prints the following sequences of values in loops:\n",
        "\n",
        "d) 18, -27, 36, -45, 54, -63\n"
      ],
      "metadata": {
        "id": "5JN4XR0w5LTR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task1d\n",
        "counter=18\n",
        "while counter<=63:\n",
        "  if counter<63:\n",
        "    if counter%2==0:\n",
        "      print(counter, end=\", \")\n",
        "    else:\n",
        "      print(counter*-1, end=\", \")\n",
        "  else:\n",
        "      print(counter*-1, end=\"\")   \n",
        "  counter=counter+9"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HWP0I64_TamQ",
        "outputId": "af9de53b-a7fa-431b-e5fe-3710f90b074a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "18, -27, 36, -45, 54, -63"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Bonus\n",
        "Write the python programs, which prints the following sequences of values in loops:\n",
        "2, -4, 6, -8, 10, 12"
      ],
      "metadata": {
        "id": "1ceEC6xH8SZr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Bonus_Question\n",
        "for i in range(2,14,2):\n",
        "    if i<12:\n",
        "      if i%4==0:  \n",
        "        print(i*-1, end=\", \")\n",
        "      else:\n",
        "        print(i, end=\", \")  \n",
        "    else:\n",
        "      print(i, end=\"\")     "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XgFNrnLTcDBc",
        "outputId": "915aa329-81b7-479c-e7f2-1774a0392c87"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2, -4, 6, -8, 10, 12"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Task 2\n",
        "Write a Python code for the following:\n",
        "\n",
        "1) Ask the user to enter the name of his favorite car.\n",
        "\n",
        "2) Ask 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",
        "\n",
        "\n",
        "Example 1: If the user enters “Toyota” and 2, your program should print the \n",
        "name “Toyota” two times.\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "Toyota\n",
        "\n",
        "2\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "Toyota\n",
        "\n",
        "Toyota\n",
        "\n",
        "\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",
        "\n",
        "Veyron\n",
        "\n",
        "5\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "Veyron\n",
        "\n",
        "Veyron\n",
        "\n",
        "Veyron\n",
        "\n",
        "Veyron\n",
        "\n",
        "Veyron\n"
      ],
      "metadata": {
        "id": "7J_EnK2O5dnM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task2\n",
        "car=input(\"Enter a car name: \")\n",
        "num=int(input(\"Enter a number: \"))\n",
        "for i in range(num):\n",
        "  print(car)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d1JLg_bUe4ZW",
        "outputId": "39cc7a4d-141a-40e5-a1ee-980d76158d59"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Toyota\n",
            "5\n",
            "Toyota\n",
            "Toyota\n",
            "Toyota\n",
            "Toyota\n",
            "Toyota\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "The output of your program should be: 2835\n",
        "since 63 + 126 + 189 + 252 + 315 + 378 + 441 + 504 + 567 = 2835\n"
      ],
      "metadata": {
        "id": "G9XJlmIt53tu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task3\n",
        "Sum=0\n",
        "for i in range(601):\n",
        "  if i%7==0 and i%9==0:\n",
        "    Sum+=i\n",
        "  else:\n",
        "    pass  \n",
        "print(Sum)       "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jpWeXb9hVgUY",
        "outputId": "4b00d1f8-1b29-4dfe-a5a2-d02c39613cb5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2835\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Task 4\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",
        "The output of your program should be: 39814\n"
      ],
      "metadata": {
        "id": "0JQIGQqj5-cw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task4\n",
        "Sum=0\n",
        "for i in range(600):\n",
        "  if i%7==0 or i%9==0:\n",
        "    if i%7==0 and i%9==0:\n",
        "      pass\n",
        "    else:\n",
        "       Sum+=i\n",
        "  else:\n",
        "    pass \n",
        "print(Sum)  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aRvFxqE5Z6b9",
        "outputId": "2752497b-e87b-427b-860a-31af169a0f51"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "39814\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Task 5\n",
        "Write the Python code of a program that displays all the odd numbers between 10 and 50 (inclusive).\n",
        "Output: 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49\n"
      ],
      "metadata": {
        "id": "GrQy2zNI6FLw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task5\n",
        "Sum=0\n",
        "for i in range(10,50):\n",
        "  if i<49:\n",
        "      if i%2!=0:\n",
        "        Sum+=i\n",
        "        print(i, end=\" \")\n",
        "      else:\n",
        "        pass\n",
        "  else:\n",
        "      print(i, end=\"\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yG0PolFNbNSH",
        "outputId": "f4070f09-5f65-495e-fa1b-fc4ecda6eeae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Task 6\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",
        "y=12−22+32−42+52.........+n^2\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "5\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "15\n",
        "\n",
        "Explanation: y = 1 - 4 + 9 - 16 + 25 = 15\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "10\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "-55\n",
        "\n",
        "Explanation: y = 1 - 4 + 9 - 16 + 25 - 36 + 49 - 64 + 81 - 100 = -55\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 3:\n",
        "\n",
        "20\n",
        "\n",
        "Sample Output 3:\n",
        "\n",
        "-210\n",
        " \n"
      ],
      "metadata": {
        "id": "yexUDXl08dJc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task6\n",
        "y=int(input(\"Enter a number: \"))\n",
        "even_sum = 0\n",
        "odd_sum = 0\n",
        "for i in range(1,y+1):\n",
        "  if i%2==0:\n",
        "    even_sum+=(i**2)*-1\n",
        "  else:\n",
        "    odd_sum+=(i**2)\n",
        "sum=even_sum+odd_sum\n",
        "print(sum)    "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZdEK6iJdze-6",
        "outputId": "b23df992-3c64-4f1e-ba31-1f91440df57c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 20\n",
            "-210\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Task 7\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",
        "[Please do not use list for this task]\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\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: The total of the odd numbers is 25 and their average is 5.0\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",
        "\n",
        "Sample Input 2:\n",
        "\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",
        "Explanation: The total is 90 = 13 + (-5) + (-17) + 99) and their average is 90/4 = 22.5\n"
      ],
      "metadata": {
        "id": "Muo9eQge8-Sw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "WXQ4vC_VE4S5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task7\n",
        "odd_sum = 0\n",
        "average = 0\n",
        "for i in range(10):\n",
        "  num=int(input(\"Enter a number: \"))\n",
        "  if num==1 or num!=0:\n",
        "    odd_sum+=num\n",
        "    average+=1\n",
        "  else:\n",
        "    pass\n",
        "print(f'The total of the odd numbers is {odd_sum} and their average is {odd_sum/average}')                             "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5VYEUpj4nUq3",
        "outputId": "48b953e2-56cb-4d2d-dfda-c5a72acecbaa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Task 8\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",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "50\n",
        "\n",
        "Sample Output 1:\n",
        "\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",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "75\n",
        "\n",
        "Sample Output 2:\n",
        "\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"
      ],
      "metadata": {
        "id": "aIipKn9sDuwY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task8\n",
        "N=int(input(\"enter a Number: \"))\n",
        "sum=0\n",
        "for i in range(N+1):\n",
        "  if i%7==0:\n",
        "    sum+=i\n",
        "  else:\n",
        "    pass\n",
        "print(sum)      "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MwdfX422WvXB",
        "outputId": "d0c38aa5-a891-409a-fe88-27bc2657b767"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter a Number: 75\n",
            "385\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Task 9\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",
        "Sample Input 1:\n",
        "\n",
        "1\n",
        "\n",
        "2\n",
        "\n",
        "3\n",
        "\n",
        "4\n",
        "\n",
        "5\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "1\n",
        "\n",
        "3\n",
        "\n",
        "6\n",
        "\n",
        "10\n",
        "\n",
        "15\n",
        " \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",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "11\n",
        "\n",
        "-29\n",
        "\n",
        "-3\n",
        "\n",
        "47\n",
        "\n",
        "50\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "11\n",
        "\n",
        "-18\n",
        "\n",
        "-21\n",
        "\n",
        "26\n",
        "\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",
        " \n"
      ],
      "metadata": {
        "id": "Lai8DRBaF4n1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task9\n",
        "sum=0\n",
        "for i in range(5):\n",
        "  num=int(input(\"Enter a number: \"))\n",
        "  sum+=num\n",
        "  print(sum)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GDoONiALZjBo",
        "outputId": "2c16cca9-d5f8-44b4-c130-a53b22603615"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "3\n",
            "6\n",
            "4\n",
            "10\n",
            "5\n",
            "15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " \n",
        "# Task 10\n",
        "Write a Python program which takes a number and prints the digits from the unit place, then the tenth, then hundredth, etc. (Right to Left)\n",
        "\n",
        "[Consider the input number to be an INTEGER. You are not allowed to use String indexing for solving this task]\n",
        "\n",
        "Example: If the user gives 32768, then print 8, 6, 7, 2, 3\n",
        "\n",
        "\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",
        "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",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "dJ4cq5ZCGPhP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task10\n",
        "num=int(input(\"Enter a number: \"))\n",
        "count=0\n",
        "while num>0:\n",
        "  count+=1\n",
        "  last_digit=num%10\n",
        "  num=num//10\n",
        "  if num>0:\n",
        "    print(last_digit, end=\", \")\n",
        "  else:\n",
        "    print(last_digit, end=\"\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7g3CQ-4Yro6A",
        "outputId": "a5803e9b-83ac-4c87-b59a-1d2330905c03"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 4000\n",
            "0, 0, 0, 4"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 11\n",
        "Write a Python program that takes a number and prints how many digits are in that number.\n",
        "\n",
        "[Consider the input number to be an INTEGER.]\n",
        "\n",
        "[You are not allowed to use len() function]\n",
        "\n",
        "Example: If the user gives 9876, your program should print 4.\n",
        "\n",
        "Hint: We may keep floor dividing by ten and count how many times this can be \n",
        "done until the number becomes 0 as illustrated below.\n",
        "\n",
        "9876 // 10 = 987, count = 1\n",
        "\n",
        "then, 987 // 10 = 98, count = 2\n",
        "\n",
        "98 // 10 = 9, count = 3\n",
        "\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",
        "\n"
      ],
      "metadata": {
        "id": "fDtb0mJBsScO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task11\n",
        "number = int(input(\"Enter a number: \"))\n",
        "while (number > 0):\n",
        "    if number//10 > 0:\n",
        "        print(number % 10, end = \", \")\n",
        "    else:\n",
        "        print(number % 10, end = \"\")\n",
        "    number = number//10    "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IjZMOZlQJ-9z",
        "outputId": "b8870e56-fe01-4c91-c778-4c107daffaf9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 9876\n",
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 12\n",
        "\n",
        "Write a Python program that takes a number from the user and prints its digits from left to right.\n",
        "\n",
        "[Consider the input number to be an INTEGER. You are not allowed to use String indexing for solving this task]\n",
        "\n",
        "Example: if the user gives 32768, then print 3, 2, 7, 6, 8\n",
        "\n",
        "\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",
        "\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",
        "To summarize and clarify:\n",
        "\n",
        "Loop 1: First, we count digits like our Task 12, say 5 in this case for 32768\n",
        "\n",
        "Loop 2: Then, we calculate 10 to the power 4 (5-1), that is 10000.\n",
        "\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",
        "\n",
        "32768 % 10000 = 2768\n",
        "\n",
        "10000 // 10 = 1000\n",
        "\n",
        "2768 // 1000 = 2\n",
        "\n",
        "2768 % 1000 = 768\n",
        "\n",
        "1000 // 10 = 100\n",
        "\n",
        "768 // 100 = 7\n",
        "\n",
        "768 % 100 = 68\n",
        "\n",
        "100 // 10 = 10\n",
        "\n",
        "68 // 10 = 6\n",
        "\n",
        "68 % 10 = 8\n",
        "\n",
        "10 // 10 = 1\n",
        "\n",
        "8 // 1 = 8\n",
        "\n",
        "8 % 1 = 0\n",
        "\n",
        "1 // 10 = 0\n",
        "\n",
        "Done. Loop ends as number has become 0.\n"
      ],
      "metadata": {
        "id": "MxDqAHTkspOx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task12\n",
        "num=int(input(\"Enter a number: \"))\n",
        "count=0\n",
        "rem_num=num\n",
        "while rem_num>0:\n",
        "  rem_num=rem_num//10\n",
        "  count=count+1\n",
        "while count>0:\n",
        "  if count==1:\n",
        "      print(num//10**(count-1),end=\"\")\n",
        "  else:\n",
        "      print(num//10**(count-1),end=\", \")\n",
        "  num=num%10**(count-1)  \n",
        "  count=count-1    "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cx0vzCvIMBLF",
        "outputId": "b88d7a49-774f-4b94-bd72-887bf913f449"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 4000\n",
            "4, 0, 0, 0"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 13\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",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "6\n",
        "Sample Output 1:\n",
        "\n",
        "1\n",
        "\n",
        "2\n",
        "\n",
        "3\n",
        "\n",
        "6\n",
        "\n",
        "Total 4 divisors.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "121\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "1\n",
        "\n",
        "11\n",
        "\n",
        "121\n",
        "\n",
        "Total 3 divisors.\n"
      ],
      "metadata": {
        "id": "UaHOP6BFtcId"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task13\n",
        "num=int(input(\"Enter a number: \"))\n",
        "count=0\n",
        "for i in range(1,num+1):\n",
        "  if num%i==0:\n",
        "    count+=1\n",
        "    print(i)\n",
        "  else:\n",
        "    pass  \n",
        "print(f'Total {count} divisors.')  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ahh1ZTgNBz00",
        "outputId": "849347e0-db3b-4ad7-eff7-255d0da4ddce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 121\n",
            "1\n",
            "11\n",
            "121\n",
            "Total 3 divisors.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 14\n",
        " \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",
        "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",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "6\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "6 is a perfect number\n",
        "\n",
        "Explanation:\n",
        "\n",
        "6 has 4 divisors: 1, 2, 3, and 6.\n",
        "\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",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "28\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "28 is a perfect number\n",
        "\n",
        "Explanation: 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",
        "\n",
        "\n",
        "Sample Input 3:\n",
        "\n",
        "33\n",
        "Sample Output 3:\n",
        "\n",
        "33 is not a perfect number\n",
        "Explanation:\n",
        "\n",
        "33 has 4 divisors: 1, 3, 11, and 33.\n",
        "\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"
      ],
      "metadata": {
        "id": "3VmoEeTGtzC4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task14\n",
        "num=int(input(\"Enter a number: \"))\n",
        "sum=0\n",
        "for i in range(1,num):\n",
        "  if num%i==0:\n",
        "    sum=sum+i\n",
        "if sum==num:\n",
        "  print(f'{num} is a perfect number')\n",
        "else:\n",
        "  print(f'{num} is not a perfect number')      \n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nViUQRM7Efaf",
        "outputId": "90b7a2a7-a83a-4670-b1bc-781d35593b8c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 28\n",
            "28 is a perfect number\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 15\n",
        "Write a Python program that asks the user for one number and tells if it is a prime number or not.\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",
        "Hint: You may use the code for counting divisors from Task 14.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "11\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "11 is a prime number\n",
        "\n",
        "Explanation: 11 has only 2 divisors: 1 and 11.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "6\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "6 is not a prime number\n",
        "\n",
        "Explanation: 6 has 4 divisors: 1, 2, 3 and 6.\n"
      ],
      "metadata": {
        "id": "5EApqQG-uzMX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task15\n",
        "num=int(input(\"Enter a number: \"))\n",
        "count=0\n",
        "for i in range(1,num):\n",
        "  if num%i==0:\n",
        "    count=count+i\n",
        "  else:\n",
        "    pass\n",
        "if count>1:\n",
        "  print(f'{num} is not a prime number') \n",
        "else:\n",
        "  print(f'{num} is a prime number')        "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dHoQEue8Js6u",
        "outputId": "8a5b4469-e7a4-44dd-9a14-9e013be93b89"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 8\n",
            "8 is not a prime number\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 16\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",
        "[Please note that you CANNOT use max, min built-in functions]\n",
        "\n",
        "[Also, you DO NOT need to use lists for this task]\n",
        "\n",
        "\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",
        "\n",
        "The output of your program should be: “Maximum 10”, “Minimum -100”, “Average is -17.2” as shown below.\n",
        "\n",
        "Input:\n",
        "\n",
        "5 \n",
        "\n",
        "10 \n",
        "\n",
        "4 \n",
        "\n",
        "-1 \n",
        "\n",
        "-100 \n",
        "\n",
        "1\n",
        "\n",
        "Output:\n",
        "\n",
        "Maximum 10\n",
        "\n",
        "Minimum -100\n",
        "\n",
        "Average is -17.2\n",
        "\n",
        "Explanation: Average calculation: (10 + 4 + (-1) + (-100) + 1)/5 = -86/5 = -17.2\n"
      ],
      "metadata": {
        "id": "6Q7TGOnIH9lP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task16\n",
        "quantity=int(input(\"Enter a number: \"))\n",
        "max=0\n",
        "min=0\n",
        "average=0\n",
        "sum=0\n",
        "for i in range(quantity):\n",
        "  num=int(input(\"Enter a number: \"))\n",
        "  sum+=num\n",
        "  average=(sum)/quantity\n",
        "  if i==0:\n",
        "    max=num\n",
        "    min=num\n",
        "  if num>max:\n",
        "    max=num\n",
        "  if num<min:\n",
        "    min=num\n",
        "print(\"Maximum\",max)\n",
        "print(\"Minimum\", min)\n",
        "print(\"Average is\", average)      "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l5WGwGEe7Goa",
        "outputId": "1f6e7a38-1d4c-464c-cd26-c760b9a864d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 17\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",
        "Hint: You may need to use nested loops to solve this problem.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "5\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "+++++\n",
        "\n",
        "+++++\n",
        "\n",
        "+++++\n",
        "\n",
        "+++++\n",
        "\n",
        "+++++\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",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "3\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "+++\n",
        "\n",
        "+++\n",
        "\n",
        "+++\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.\n",
        " \n"
      ],
      "metadata": {
        "id": "0Zllhg5LJVDt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task17\n",
        "N=int(input(\"Enter a number: \"))\n",
        "for i in range(N):\n",
        "  for j in range(N):\n",
        "    print(\"+\",end=\"\")\n",
        "  print()    "
      ],
      "metadata": {
        "id": "WWtAQFEiMTTM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e42f6b74-a1ed-41a4-9bdb-8e85ac784202"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 3\n",
            "+++\n",
            "+++\n",
            "+++\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 18\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",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "4\n",
        "\n",
        "6\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "123456\n",
        "\n",
        "123456\n",
        "\n",
        "123456\n",
        "\n",
        "123456\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",
        "\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "3\n",
        "\n",
        "2\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "12\n",
        "\n",
        "12\n",
        "\n",
        "12\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"
      ],
      "metadata": {
        "id": "a7Af-S4h-n3Q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task18\n",
        "N=int(input(\"Enter a number: \"))\n",
        "M=int(input(\"Enter a number: \"))\n",
        "for i in range(N):\n",
        "  for j in range(M):\n",
        "    print(j+1,end=\"\")\n",
        "  print()  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C1BBooQ_gTzD",
        "outputId": "a86c26a8-94ce-4446-e805-2903634e2a06"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 3\n",
            "Enter a number: 2\n",
            "12\n",
            "12\n",
            "12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 19\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",
        "Hint: You may need to use nested loops. Try to think up to which point should the inner loop run.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "4\n",
        "Sample Output 1:\n",
        "\n",
        "1\n",
        "\n",
        "12\n",
        "\n",
        "123\n",
        "\n",
        "1234\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",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "5\n",
        "Sample Output 2:\n",
        "\n",
        "1\n",
        "\n",
        "12\n",
        "\n",
        "123\n",
        "\n",
        "1234\n",
        "\n",
        "12345\n",
        "\n",
        "Explanation: Numbers are printed sequentially up to the line number for each of the lines.\n",
        " \n"
      ],
      "metadata": {
        "id": "Wm8Zc8C4_OQM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task19\n",
        "N=int(input(\"Enter a number: \"))\n",
        "for i in range(N):\n",
        "  for j in range(i+1):\n",
        "    print(j+1,end=\"\")\n",
        "  print()  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9uJ4TD-zkzr3",
        "outputId": "95f5c407-e6be-425e-c6f1-4fbe5bb451cd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 5\n",
            "1\n",
            "12\n",
            "123\n",
            "1234\n",
            "12345\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Optional Tasks (25 - 29) [Ungraded]\n",
        "\n",
        "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.\n",
        "\n",
        " \n",
        "# Task 25\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",
        "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:\n",
        "\n",
        "10\n",
        "\n",
        "Sample Output 1:\n",
        "\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",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "15\n",
        "\n",
        "Sample Output 2:\n",
        "\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.\n"
      ],
      "metadata": {
        "id": "u_uFwpYLARZj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task25\n",
        "num=int(input(\"Enter a number: \"))\n",
        "var1=0\n",
        "var2=1\n",
        "sum=0\n",
        "if num<=0:\n",
        "  print(\"please enter a positive number\")\n",
        "else:\n",
        "  for i in range(0,num):\n",
        "    if sum<=num:\n",
        "      print(sum,end=\" \")  \n",
        "      var1=var2\n",
        "      var2=sum\n",
        "      sum=var1+var2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rlVB30nv62gJ",
        "outputId": "ef0b2216-ab77-487d-bbfd-53dc16eb2728"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 10\n",
            "0 1 1 2 3 5 8 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 26\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",
        "\n",
        "\n",
        "Example 1:\n",
        "For example, to convert 11 to a binary number, we can try the following approach.\n",
        "\n",
        "11 // 2 = 5 (Remainder 1)\n",
        "\n",
        "5 // 2 = 2 (Remainder 1)\n",
        "\n",
        "2 // 2 = 1 (Remainder 0)\n",
        "\n",
        "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:\n",
        "\n",
        "11\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "1011\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example 2:\n",
        "\n",
        "Similarly, to convert 13 to a binary number:\n",
        "\n",
        "13 // 2 = 6 (Remainder 1)\n",
        "\n",
        "6 // 2 = 3 (Remainder 0)\n",
        "\n",
        "3 // 2 = 1 (Remainder 1)\n",
        "\n",
        "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:\n",
        "\n",
        "13\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "1101\n"
      ],
      "metadata": {
        "id": "MBNAFygY_kAE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task26\n",
        "num=int(input(\"Enter a number: \"))\n",
        "c=0\n",
        "for i in range(num,0,-1):\n",
        "  if c>=0:\n",
        "    c+=i//2\n",
        "    print(i%1)\n",
        "    c+=1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jd5qP1bvA2QK",
        "outputId": "83569d12-d377-451a-e87d-7830d47d69c0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 11\n",
            "41\n"
          ]
        }
      ]
    }
  ]
}