PythonBasics1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Python Basics 1"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Contents:  \r\n",
    "* Introduction to   \r\n",
    "* Conditionals and Loops  \r\n",
    "* Pattern 1  \r\n",
    "* Pattern 2  \r\n",
    "* More on Loops  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Introduction to Python"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 1\r\n",
    "Write a program to input marks of three tests of a student (all integers). Then calculate and print the average of all test marks.  \r\n",
    "\r\n",
    "Sample Input 1 :  \r\n",
    "3  \r\n",
    "4  \r\n",
    "6  \r\n",
    "\r\n",
    "Sample Output 1 :  \r\n",
    "4.333333333333333"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "a = int(input())\r\n",
    "b = int(input())\r\n",
    "c = int(input())\r\n",
    "d = (a+b+c)/3\r\n",
    "print(d)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "4.333333333333333\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 2\r\n",
    "You are given two integers: X and N. You have to calculate X raised to power N and print it.\r\n",
    "\r\n",
    "**Input format:**\r\n",
    "The first line of input contains an integer X (1 <= X <= 100)\r\n",
    "The second line of input contains an integer N (1 <= N <= 10) \r\n",
    "\r\n",
    "**Constraints:**\r\n",
    "Time Limit: 1 second\r\n",
    "\r\n",
    "**Output format:**\r\n",
    "The first and only line of output contains the result.  \r\n",
    "\r\n",
    "Sample Input:  \r\n",
    "10  \r\n",
    "4  \r\n",
    "\r\n",
    "Sample Output:  \r\n",
    "10000"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "X = int(input())\r\n",
    "N = int(input())\r\n",
    "\r\n",
    "a = X**N\r\n",
    "\r\n",
    "print(a)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "10000\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 3\r\n",
    "*Arithmetic Progression*\r\n",
    "\r\n",
    "You are given first three entries of an arithmetic progression. You have to calculate the common difference and print it.\r\n",
    "\r\n",
    "**Input format:**\r\n",
    "The first line of input contains an integer a (1 <= a <= 100)  \r\n",
    "The second line of input contains an integer b (1 <= b <= 100)   \r\n",
    "The third line of input contains an integer c (1 <= c <= 100)  \r\n",
    "\r\n",
    "**Constraints:**\r\n",
    "Time Limit: 1 second\r\n",
    "\r\n",
    "**Output format:**\r\n",
    "The first and only line of output contains the result.  \r\n",
    "\r\n",
    "Sample Input:  \r\n",
    "1  \r\n",
    "3  \r\n",
    "5  \r\n",
    "Sample Output:  \r\n",
    "2"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "a  = int(input())\r\n",
    "b  = int(input())\r\n",
    "c  = int(input())\r\n",
    "\r\n",
    "d = c - b\r\n",
    "\r\n",
    "print(d)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 4\r\n",
    "*Rectangular Area*\r\n",
    "\r\n",
    "You are given a rectangle in a plane. The corner coordinates of this rectangle is provided to you. You have to print the amount of area of the plane covered by this rectangle.\r\n",
    "The end coordinates are provided as four integral values: x1, y1, x2, y2. It is given that x1 < x2 and y1 < y2.\r\n",
    "\r\n",
    "**Input format:**  \r\n",
    "The first line of input contains an integer x1 (1 <= x1 <= 10)  \r\n",
    "The second line of input contains an integer y1 (1 <= y1 <= 10)  \r\n",
    "The third line of input contains an integer x2 (1 <= x2 <= 10)  \r\n",
    "The fourth line of input contains an integer y2 (1 <= y2 <= 10)  \r\n",
    "\r\n",
    "**Constraints:**\r\n",
    "Time Limit: 1 second\r\n",
    "\r\n",
    "**Output format:** \r\n",
    "The first and only line of output contains the result.  \r\n",
    "\r\n",
    "Sample Input:  \r\n",
    "1  \r\n",
    "1  \r\n",
    "3  \r\n",
    "3  \r\n",
    "\r\n",
    "Sample Output:  \r\n",
    "4  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "x1 = int(input())\r\n",
    "x2 = int(input())\r\n",
    "y1 = int(input())\r\n",
    "y2 = int(input())\r\n",
    "\r\n",
    "a = x1 - y1\r\n",
    "b = x2 - y2\r\n",
    "d = a * b\r\n",
    "\r\n",
    "print(d)\r\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "4\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Conditionals and Loops"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 1"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Check Number\r\n",
    "\r\n",
    "Given an integer n, find if n is positive, negative or 0.\r\n",
    "If n is positive, print \"Positive\"\r\n",
    "If n is negative, print \"Negative\"\r\n",
    "And if n is equal to 0, print \"Zero\".\r\n",
    "\r\n",
    "Input Format :  \r\n",
    "Integer n  \r\n",
    "Output Format :  \r\n",
    "\"Positive\" or \"Negative\" or \"Zero\" (without double quotes)\r\n",
    "\r\n",
    "**Constraints :**\r\n",
    "1 <= n <= 100  \r\n",
    "\r\n",
    "Sample Input 1 :  \r\n",
    "10  \r\n",
    "Sample Output 1 :  \r\n",
    "Positive  \r\n",
    "Sample Input 2 :  \r\n",
    "-10  \r\n",
    "Sample Output 2 :  \r\n",
    "Negative  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\r\n",
    "if (n > 0):\r\n",
    "    print(\"Positive\")\r\n",
    "elif (n == 0):\r\n",
    "    print(\"Zero\")\r\n",
    "else:\r\n",
    "    print(\"Negative\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Negative\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 2"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Sum of n numbers\r\n",
    "\r\n",
    "Given an integer n, find and print the sum of numbers from 1 to n.  \r\n",
    "Note : Use while loop only.  \r\n",
    "\r\n",
    "Input Format :  \r\n",
    "Integer n  \r\n",
    "Output Format :  \r\n",
    "Sum  \r\n",
    "\r\n",
    "Constraints :  \r\n",
    "1 <= n <= 100\r\n",
    "\r\n",
    "Sample Input :  \r\n",
    "10  \r\n",
    "Sample Output :  \r\n",
    "55  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n  = int(input())\r\n",
    "ctr = 1\r\n",
    "sum = 0\r\n",
    "while ctr <= n:\r\n",
    "    sum = sum + ctr\r\n",
    "    ctr = ctr + 1\r\n",
    "print(sum)  "
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "55\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Quesstion 3"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Sum of Even Numbers\r\n",
    "\r\n",
    "Given a number N, print sum of all even numbers from 1 to N.  \r\n",
    "\r\n",
    "Input Format :  \r\n",
    "Integer N  \r\n",
    "Output Format :  \r\n",
    "Required Sum   \r\n",
    "\r\n",
    "Sample Input 1 :  \r\n",
    " 6  \r\n",
    "Sample Output 1 :  \r\n",
    "12"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "N = int(input())\r\n",
    "i = 1\r\n",
    "sum = 0\r\n",
    "while i <= N:\r\n",
    "    if (i % 2 ==0):\r\n",
    "        sum = sum + i\r\n",
    "        i = i + 1\r\n",
    "    else:\r\n",
    "        i = i + 1\r\n",
    "print(sum)  "
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "12\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 4"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Prime Number\r\n",
    "\r\n",
    "Check to see weather a given number n is prime or not."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\r\n",
    "d = 2\r\n",
    "flag = False\r\n",
    "while d < n:\r\n",
    "    if(n%d==0):\r\n",
    "        flag = True\r\n",
    "    d = d + 1\r\n",
    "\r\n",
    "if flag:\r\n",
    "    print(\"Not prime\")\r\n",
    "else:\r\n",
    "    print(\"prime\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Not prime\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 5"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Check all prime numbers from 2 to n\r\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\r\n",
    "k = 2\r\n",
    "\r\n",
    "while(k <= n):\r\n",
    "    d = 2\r\n",
    "    flag = False\r\n",
    "    while (d < k):\r\n",
    "        if(k % d == 0):\r\n",
    "            flag = True\r\n",
    "        d = d + 1\r\n",
    "    if not flag:\r\n",
    "        print(k)\r\n",
    "    k = k + 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n",
      "29\n",
      "31\n",
      "37\n",
      "41\n",
      "43\n",
      "47\n",
      "53\n",
      "59\n",
      "61\n",
      "67\n",
      "71\n",
      "73\n",
      "79\n",
      "83\n",
      "89\n",
      "97\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 6"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Fahrenheit to Celsius\r\n",
    "\r\n",
    "Given three values - Start Fahrenheit Value (S), End Fahrenheit value (E) and Step Size (W), you need to convert all Fahrenheit values from Start to End at the gap of W, into their corresponding Celsius values and print the table.  \\\r\n",
    "\r\n",
    "Input Format :  \r\n",
    "3 integers - S, E and W respectively   \r\n",
    "\r\n",
    "Output Format :  \r\n",
    "Fahrenheit to Celsius conversion table. One line for every Fahrenheit and corresponding Celsius value. On Fahrenheit value and its corresponding Celsius value should be separate by tab (\"\\t\")  \r\n",
    "\r\n",
    "Constraints :  \r\n",
    "0 <= S <= 80  \r\n",
    "S <= E <=  900  \r\n",
    "0 <= W <= 40   \r\n",
    "\r\n",
    "Sample Input 1:  \r\n",
    "0   \r\n",
    "100   \r\n",
    "20  \r\n",
    "\r\n",
    "Sample Output 1:  \r\n",
    "0   -17  \r\n",
    "20  -6  \r\n",
    "40  4  \r\n",
    "60  15  \r\n",
    "80  26  \r\n",
    "100 37  \r\n",
    "\r\n",
    "Sample Input 2:  \r\n",
    "20  \r\n",
    "119  \r\n",
    "13  \r\n",
    "\r\n",
    "Sample Output 2:  \r\n",
    "20  -6  \r\n",
    "33  0  \r\n",
    "46  7  \r\n",
    "59  15  \r\n",
    "72  22  \r\n",
    "85  29  \r\n",
    "98  36  \r\n",
    "111 43  \r\n",
    "\r\n",
    "*Explanation For Input 2:*  \r\n",
    "We need need to start calculating the Celsius values for each of the Fahrenheit Value which starts from 20. So starting from 20 which is the given Fahrenheit start value, we need to compute its corresponding Celsius value which computes to -6. We print this information as <Fahrenheit Value> a tab space\"\\t\" <Celsius Value> on each line for each step of 13 we take to get the next value of Fahrenheit and extend this idea till we reach the end that is till 119 in this case. You may or may not exactly land on the end value depending on the steps you are taking."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "S = int(input())\r\n",
    "E = int(input())\r\n",
    "W = int(input())\r\n",
    "\r\n",
    "while(S <= E):\r\n",
    "    cel = (S - 32) * 5/9\r\n",
    "    print(S,\" \",int(cel))\r\n",
    "    S = S + W"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "0   -17\n",
      "20   -6\n",
      "40   4\n",
      "60   15\n",
      "80   26\n",
      "100   37\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Questoin 7"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Calculator\r\n",
    "\r\n",
    "Write a program that performs the tasks of a simple calculator. The program should first take an integer as input and then based on that integer perform the task as given below. \r\n",
    "\r\n",
    "1. If the input is 1, then 2 integers are taken from the user and their sum is printed.  \r\n",
    "2. If the input is 2, then 2 integers are taken from the user and their difference(1st number - 2nd number) is printed.  \r\n",
    "3. If the input is 3, then 2 integers are taken from the user and their product is printed.  \r\n",
    "4. If the input is 4, then 2 integers are taken from the user and the quotient obtained (on dividing 1st number by 2nd number) is printed.  \r\n",
    "5. If the input is 5, then 2 integers are taken from the user and their remainder(1st number mod 2nd number) is printed.  \r\n",
    "6. If the input is 6, then the program exits.  \r\n",
    "7. For any other input, then print \"Invalid Operation\".\r\n",
    "\r\n",
    "Note: Each answer in next line.  \r\n",
    "\r\n",
    "Input format:\r\n",
    "Take integers as input, in accordance to the description of the question. \r\n",
    "\r\n",
    "Constraints:\r\n",
    "Time Limit: 1 second\r\n",
    "\r\n",
    "Output format:\r\n",
    "The output lines must be as prescribed in the description of the question.\r\n",
    "\r\n",
    "Sample Input:\r\n",
    "3  \r\n",
    "1  \r\n",
    "2  \r\n",
    "4  \r\n",
    "4  \r\n",
    "2  \r\n",
    "1  \r\n",
    "3  \r\n",
    "2  \r\n",
    "7  \r\n",
    "6  \r\n",
    "\r\n",
    "Sample Output:\r\n",
    "2  \r\n",
    "2  \r\n",
    "5  \r\n",
    "\r\n",
    "Invalid Operation\r\n",
    "Explanation of the sample input\r\n",
    "The first number given is 3, so that means two more numbers will be given and we'll have to multiply them and show the result. The two numbers are 1 and 2. Their product is 2, so 2 is displayed first in the output. Similarly, all the numbers are processed in groups of three. The first number tells the operation and the next two numbers tell on which numbers the operation is done. This applies to numbers from 1 to 5. If the input is 6 (like it is at the end), two more numbers will NOT be provided, you simply have to exit the program. Also, if the input is any number except 1 to 6 (like 7 which is at the second last), then you simply have to print \"Invalid Operation\""
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "while(1):\r\n",
    "    a = int(input())\r\n",
    "    \r\n",
    "    if (a ==1):\r\n",
    "        x = int(input())\r\n",
    "        y = int(input())\r\n",
    "        print(x+y)\r\n",
    "    elif(a == 2):\r\n",
    "        x = int(input())\r\n",
    "        y = int(input())\r\n",
    "        print(x-y)\r\n",
    "    elif(a == 3):\r\n",
    "        x = int(input())\r\n",
    "        y = int(input())\r\n",
    "        print(x*y)\r\n",
    "    elif(a == 4):\r\n",
    "        x = int(input())\r\n",
    "        y = int(input())\r\n",
    "        print(int(x/y))\r\n",
    "    elif(a == 5):\r\n",
    "        x = int(input())\r\n",
    "        y = int(input())\r\n",
    "        print(x%y)\r\n",
    "    elif(a == 6):\r\n",
    "        break\r\n",
    "    else:\r\n",
    "        print(\"Invalid Operation\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 8"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Reverse of a number  \r\n",
    "\r\n",
    "Write a program to generate the reverse of a given number N. Print the corresponding reverse number.  \r\n",
    "Note : If a number has trailing zeros, then its reverse will not include them. For e.g., reverse of 10400 will be 401 instead of 00401.  \r\n",
    "\r\n",
    "Input format :  \r\n",
    "Integer N\r\n",
    "\r\n",
    "Output format :  \r\n",
    "Corresponding reverse number\r\n",
    "\r\n",
    "Constraints:  \r\n",
    "0 <= N < 10^8  \r\n",
    "\r\n",
    "Sample Input 1 :  \r\n",
    "1234\r\n",
    "\r\n",
    "Sample Output 1 :  \r\n",
    "4321\r\n",
    "\r\n",
    "Sample Input 2 :  \r\n",
    "1980\r\n",
    "\r\n",
    "Sample Output 2 :  \r\n",
    "891"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "def reverse(n):\r\n",
    "    rev = 0\r\n",
    "    while(n > 0):\r\n",
    "        reminder = n % 10\r\n",
    "        rev = (rev * 10) + reminder\r\n",
    "        n = n // 10\r\n",
    "    return rev \r\n",
    "\r\n",
    "\r\n",
    "n=int(input())\r\n",
    "result = reverse(n)\r\n",
    "print(result)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "891\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 9\r\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Palindrome number\r\n",
    "\r\n",
    "Write a program to determine if given number is palindrome or not. Print true if it is palindrome, false otherwise.  \r\n",
    "Palindrome are the numbers for which reverse is exactly same as the original one. For eg. 121  \r\n",
    "\r\n",
    "Sample Input 1 :  \r\n",
    "121  \r\n",
    "Sample Output 1 :  \r\n",
    "true\r\n",
    "\r\n",
    "Sample Input 2 :  \r\n",
    "1032  \r\n",
    "Sample Output 2 :  \r\n",
    "false"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "def checkPalindrome(num):\r\n",
    "    temp = num\r\n",
    "    rev = 0\r\n",
    "    while(num > 0):\r\n",
    "        reminder = num % 10\r\n",
    "        rev = (rev * 10) + reminder\r\n",
    "        num = num // 10\r\n",
    "        \r\n",
    "    if (temp == rev):\r\n",
    "        return True\r\n",
    "    else:\r\n",
    "        return False\r\n",
    "     \r\n",
    "     \r\n",
    "num = int(input())\r\n",
    "isPalindrome = checkPalindrome(num)\r\n",
    "if(isPalindrome):\r\n",
    "\tprint('true')\r\n",
    "else:\r\n",
    "\tprint('false')\r\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "false\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 10\r\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Sum of even & odd\r\n",
    "\r\n",
    "Write a program to input an integer N and print the sum of all its even digits and sum of all its odd digits separately.  \r\n",
    "Digits mean numbers, not the places! That is, if the given integer is \"13245\", even digits are 2 & 4 and odd digits are 1, 3 & 5.  \r\n",
    "\r\n",
    "Input format :\r\n",
    " Integer N\r\n",
    "\r\n",
    "Output format :\r\n",
    "Sum_of_Even_Digits Sum_of_Odd_Digits\r\n",
    "(Print first even sum and then odd sum separated by space)\r\n",
    "\r\n",
    "Constraints\r\n",
    "0 <= N <= 10^8\r\n",
    "\r\n",
    "Sample Input 1:  \r\n",
    "1234  \r\n",
    "Sample Output 1:  \r\n",
    "6 4\r\n",
    "\r\n",
    "Sample Input 2:  \r\n",
    "552245  \r\n",
    "Sample Output 2:  \r\n",
    "8 15\r\n",
    "\r\n",
    "Explanation for Input 2:  \r\n",
    "For the given input, the even digits are 2, 2 and 4 and if we take the sum of these digits it will come out to be 8(2 + 2 + 4) and similarly, if we look at the odd digits, they are, 5, 5 and 5 which makes a sum of 15(5 + 5 + 5). Hence the answer would be, 8(evenSum) <single space> 15(oddSum)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "N = int(input())\r\n",
    "# To parse through the whole string.\r\n",
    "#remember to keep initialization such as even and odd here outside the loop.\r\n",
    "even = 0\r\n",
    "odd = 0\r\n",
    "while(N > 0):\r\n",
    "    rem = N % 10\r\n",
    "    N = N // 10\r\n",
    "    if (rem % 2 == 0):\r\n",
    "        even = even + rem\r\n",
    "    else:\r\n",
    "        odd = odd + rem    \r\n",
    "print(even,\" \", odd)\r\n",
    "    "
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "8   15\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 11"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Nth Fibonacci Number\r\n",
    "\r\n",
    "Nth term of Fibonacci series F(n), where F(n) is a function, is calculated using the following formula -  \r\n",
    "    F(n) = F(n-1) + F(n-2),   \r\n",
    "    Where, F(1) = F(2) = 1  \r\n",
    "Provided N you have to find out the Nth Fibonacci Number.  \r\n",
    "\r\n",
    "Input Format :  \r\n",
    "The first line of each test case contains a real number ‘N’.  \r\n",
    "Output Format :  \r\n",
    "For each test case, return its equivalent Fibonacci number.  \r\n",
    "Constraints:  \r\n",
    "1 <= N <= 10000       \r\n",
    "Where ‘N’ represents the number for which we have to find its equivalent Fibonacci number.  \r\n",
    "\r\n",
    "Time Limit: 1 second  \r\n",
    "Sample Input 1:  \r\n",
    "6  \r\n",
    "Sample Output 1:  \r\n",
    "8  \r\n",
    "\r\n",
    "Explanation of Sample Input 1:  \r\n",
    "Now the number is ‘6’ so we have to find the “6th” Fibonacci number  \r\n",
    "So by using the property of the Fibonacci series i.e   \r\n",
    "\r\n",
    "[ 1, 1, 2, 3, 5, 8]  \r\n",
    "So the “6th” element is “8” hence we get the output."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "N = int(input())\n",
    "N1 = 0\n",
    "N2 = 1\n",
    "i = 1\n",
    "if(N == 1):\n",
    "    print(1)\n",
    "else:\n",
    "    while(i<N):\n",
    "        Nth = N1 +N2\n",
    "        N1 = N2\n",
    "        N2 = Nth\n",
    "        i += 1\n",
    "    print(Nt) \n",
    "    "
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "8\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\r\n",
    "a = 0\r\n",
    "b = 1\r\n",
    "\r\n",
    "c = -1\r\n",
    "for i in range(n):\r\n",
    "    c = a + b\r\n",
    "    a = b\r\n",
    "    b = c\r\n",
    "print(a)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "8\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Patterns 1"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Example"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "'****  \n",
    "'****  \n",
    "'****  \n",
    "'****  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "while i <= n:\n",
    "    j = 1\n",
    "    while j <= n:\n",
    "        print(\"*\",end=\"\")\n",
    "        j = j + 1\n",
    "    # empty print to go to the next line\n",
    "    print()\n",
    "    i = i + 1\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "**\n",
      "**\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Questoin 1"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Code : Square Pattern\n",
    "\n",
    "Print the following pattern for the given N number of rows.\n",
    "Pattern for N = 4  \n",
    "4444  \n",
    "4444  \n",
    "4444  \n",
    "4444  \n",
    "\n",
    "Input format :  \n",
    "Integer N (Total no. of rows)  \n",
    "\n",
    "Output format :\n",
    "Pattern in N lines\n",
    "\n",
    "Constraints  \n",
    "0 <= N <= 50  \n",
    "\n",
    "Sample Input 1:    \n",
    "7  \n",
    "Sample Output 1:  \n",
    "7777777  \n",
    "7777777  \n",
    "7777777  \n",
    "7777777  \n",
    "7777777  \n",
    "7777777  \n",
    "7777777  \n",
    "\n",
    "Sample Input 1:  \n",
    "6\n",
    "\n",
    "Sample Output 1:  \n",
    "666666  \n",
    "666666  \n",
    "666666  \n",
    "666666  \n",
    "666666  \n",
    "666666  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "N = int(input())\n",
    "i = 1\n",
    "while i <= N:\n",
    "    j = 1\n",
    "    while j <= N:\n",
    "        print(N,end = '')\n",
    "        j = j+1\n",
    "    print()\n",
    "    i +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1111\n",
      "2222\n",
      "3333\n",
      "4444\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Square patterns"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "N = int(input())\n",
    "i = 1\n",
    "while i<= N:\n",
    "    j = 1\n",
    "    while j <= N:\n",
    "        print(i,end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1111\n",
      "2222\n",
      "3333\n",
      "4444\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "N = int(input())\n",
    "i = 1\n",
    "while i<= N:\n",
    "    j = 1\n",
    "    while j <= N:\n",
    "        print(j,end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1234\n",
      "1234\n",
      "1234\n",
      "1234\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "N = int(input())\n",
    "i = 1\n",
    "while i<= N:\n",
    "    j = 1\n",
    "    while j <= N:\n",
    "        print(N- j + 1,end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "4321\n",
      "4321\n",
      "4321\n",
      "4321\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Triangle Pattern"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "N = int(input())\n",
    "i = 1\n",
    "while i<= N:\n",
    "    j = 1\n",
    "    while j <= i:\n",
    "        print(j,end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "12\n",
      "123\n",
      "1234\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "while i <= n:\n",
    "    j = 1\n",
    "    p = i\n",
    "    while j <= i:\n",
    "        print(p, end=\"\")\n",
    "        j = j+1\n",
    "        p = p+1\n",
    "    print()\n",
    "    i = i + 1  \n",
    "        "
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "23\n",
      "345\n",
      "4567\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# In previos question we reset p now we have it globally\n",
    "n = int(input())\n",
    "i =1\n",
    "p =1\n",
    "while i<=n:\n",
    "    j =1\n",
    "    while j <=i:\n",
    "        print(p,end ='')\n",
    "        p = p +1\n",
    "        j =j+1\n",
    "    print()\n",
    "    i = i + 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "23\n",
      "456\n",
      "78910\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 2"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Code : Triangular Star Pattern  \n",
    "\n",
    "Print the following pattern for the given N number of rows.  \n",
    "Pattern for N = 4  \n",
    "'*  \n",
    "'**  \n",
    "'***  \n",
    "'****  \n",
    "\n",
    "Note : There are no spaces between the stars (*).\n",
    "\n",
    "Input format :\n",
    "Integer N (Total no. of rows)\n",
    "\n",
    "Output format :\n",
    "Pattern in N lines\n",
    "\n",
    "Constraints\n",
    "0 <= N <= 50\n",
    "\n",
    "Sample Input 1:  \n",
    "5  \n",
    "Sample Output 1:  \n",
    "'*  \n",
    "'**  \n",
    "'***  \n",
    "'****  \n",
    "'*****  \n",
    "Sample Input 2:  \n",
    "6  \n",
    "Sample Output 2:  \n",
    "'*  \n",
    "'**  \n",
    "'***  \n",
    "'****  \n",
    "'*****  \n",
    "'******"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "while i <= n:\n",
    "    j = 1\n",
    "    while j <= i:\n",
    "        print(\"*\", end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1\n",
    "\n",
    "    "
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "*\n",
      "**\n",
      "***\n",
      "****\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 3"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Code : Triangle Number Pattern\n",
    "\n",
    "Print the following pattern for the given N number of rows.  \n",
    "Pattern for N = 4  \n",
    "\n",
    "1  \n",
    "22  \n",
    "333  \n",
    "4444  \n",
    "\n",
    "Input format :  \n",
    "Integer N (Total no. of rows)\n",
    "\n",
    "Output format : \n",
    "Pattern in N lines  \n",
    "\n",
    "Constraints \n",
    "0 <= N <= 50\n",
    "\n",
    "Sample Input 1: \n",
    "5   \n",
    "Sample Output 1:  \n",
    "\n",
    "1   \n",
    "22  \n",
    "333  \n",
    "4444    \n",
    "55555   \n",
    "\n",
    "Sample Input 2: \n",
    "6   \n",
    "Sample Output 2:  \n",
    "  \n",
    "1   \n",
    "22  \n",
    "333  \n",
    "4444    \n",
    "55555   \n",
    "666666  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\r\n",
    "i =1\r\n",
    "while i <= n:\r\n",
    "    j = 1\r\n",
    "    while j <= i:\r\n",
    "        print(i,end='')\r\n",
    "        j += 1\r\n",
    "    print()\r\n",
    "    i +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "22\n",
      "333\n",
      "4444\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Code : Reverse Number Pattern\n",
    "\n",
    "Print the following pattern for the given N number of rows. \n",
    "Pattern for N = 4   \n",
    "\n",
    "1   \n",
    "21  \n",
    "321 \n",
    "4321    \n",
    "\n",
    "Input format :  \n",
    "Integer N (Total no. of rows)\n",
    "\n",
    "Output format :\n",
    "Pattern in N lines  \n",
    "\n",
    "Constraints  \n",
    "0 <= N <= 50  \n",
    "\n",
    "Sample Input 1:  \n",
    "5  \n",
    "Sample Output 1:  \n",
    "\n",
    "1  \n",
    "21  \n",
    "321  \n",
    "4321    \n",
    "54321   \n",
    "Sample Input 2:  \n",
    "6   \n",
    "Sample Output 2:    \n",
    "1   \n",
    "21  \n",
    "321  \n",
    "4321    \n",
    "54321   \n",
    "654321  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 4"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\r\n",
    "i =1\r\n",
    "while i <= n:\r\n",
    "    j = 1\r\n",
    "    p = i\r\n",
    "    while j <= i:\r\n",
    "        print(p,end='')\r\n",
    "        j += 1\r\n",
    "        p = p -1\r\n",
    "    print()\r\n",
    "    i +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "21\n",
      "321\n",
      "4321\n",
      "54321\n",
      "654321\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Printing kth term"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "k = int (input())\n",
    "# 'A' +k - 1\n",
    "x = ord ('A')\n",
    "assci_target = x +  k - 1\n",
    "target_char = chr(assci_target)\n",
    "print (target_char)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "E\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "ABCD    \n",
    "ABCD    \n",
    "ABCD    \n",
    "ABCD"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "while (i <= n):\n",
    "    j = 1\n",
    "    while( j <= n):\n",
    "        charP = chr(ord('A') + j - 1) # to get the character.\n",
    "        print(charP,end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "ABCD\n",
      "ABCD\n",
      "ABCD\n",
      "ABCD\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "ABCD    \n",
    "BCDE    \n",
    "CDEF    \n",
    "DEFG"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "while (i <= n):\n",
    "    j = 1\n",
    "    start_char = chr(ord('A') + i - 1)\n",
    "    while( j <= n):\n",
    "        charP = chr(ord(start_char) + j - 1) # to get the character.\n",
    "        print(charP,end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "ABCD\n",
      "BCDE\n",
      "CDEF\n",
      "DEFG\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 5"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Character Pattern\n",
    "\n",
    "Print the following pattern for the given N number of rows.  \n",
    "Pattern for N = 4  \n",
    "\n",
    "A   \n",
    "BC  \n",
    "CDE    \n",
    "DEFG  \n",
    "\n",
    "Input format :      \n",
    "Integer N (Total no. of rows)   \n",
    "\n",
    "Output format : \n",
    "Pattern in N lines\n",
    "\n",
    "Constraints \n",
    "0 <= N <= 13\n",
    "\n",
    "Sample Input 1: \n",
    "5   \n",
    "Sample Output 1:   \n",
    "\n",
    "A   \n",
    "BC  \n",
    "CDE  \n",
    "DEFG    \n",
    "EFGHI   \n",
    "\n",
    "Sample Input 2:   \n",
    "6   \n",
    "\n",
    "Sample Output 2:    \n",
    "\n",
    "A   \n",
    "BC  \n",
    "CDE  \n",
    "DEFG    \n",
    "EFGHI   \n",
    "FGHIJK   "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "while i <= n :\n",
    "    j = 1\n",
    "    start_char = chr(ord('A') + i -1)\n",
    "     \n",
    "    while j <= i:\n",
    "        charP = chr(ord(start_char) + j -1)\n",
    "        print(charP, end = '')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1\n",
    "    "
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "A\n",
      "BC\n",
      "CDE\n",
      "DEFG\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Same solution can also be done by no chr in earlier stages\n",
    "n = int(input()) \n",
    "currRow = 1 \n",
    "while currRow <= n:\n",
    "    currCol = 1 \n",
    "    ch = ord('A') + currRow - 1 \n",
    "    while currCol <= currRow: \n",
    "        print(chr(ch + currCol - 1), end = \"\")\n",
    "        currCol += 1 \n",
    "    print() \n",
    "    currRow += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "A\n",
      "BC\n",
      "CDE\n",
      "DEFG\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 6"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Pattern for N = 5  \n",
    "\n",
    "E  \n",
    "DE  \n",
    "CDE  \n",
    "BCDE  \n",
    "ABCDE"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "while i <= n :\n",
    "    j = 1\n",
    "    start_char = chr(ord('A') + n -1)\n",
    "     \n",
    "    while j <= i:\n",
    "        charP = chr(ord(start_char)-i +j)\n",
    "        print(charP, end = '')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "E\n",
      "DE\n",
      "CDE\n",
      "BCDE\n",
      "ABCDE\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1 \n",
    "while i <= n:\n",
    "    j =1\n",
    "    ch = ord('A') + n - i\n",
    "    while j <=i:\n",
    "        print(chr(ch+j-1), end ='')\n",
    "        j +=1   \n",
    "    print()\n",
    "    i +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "E\n",
      "DE\n",
      "CDE\n",
      "BCDE\n",
      "ABCDE\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 7"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Number Pattern 1\n",
    "\n",
    "Print the following pattern for the given N number of rows.  \n",
    "Pattern for N = 4  \n",
    "1  \n",
    "11   \n",
    "111   \n",
    "1111 "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "while i<=n:\n",
    "    j = 1\n",
    "    while j<=i:\n",
    "        print('1',end='')\n",
    "        j +=1\n",
    "    print()\n",
    "    i +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "11\n",
      "111\n",
      "1111\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 8"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Number Pattern 2\n",
    "\n",
    "Print the following pattern for the given N number of rows.  \n",
    "Pattern for N = 4\n",
    "\n",
    "1  \n",
    "11  \n",
    "121  \n",
    "1221  \n",
    "\n",
    "Input format :  \n",
    "Integer N (Total no. of rows)\n",
    "\n",
    "Output format : \n",
    "Pattern in N lines\n",
    "\n",
    "Sample Input :  \n",
    "5 \n",
    "\n",
    "Sample Output :  \n",
    "1  \n",
    "11  \n",
    "121  \n",
    "1221  \n",
    "12221  \n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "print(\"1\")\n",
    "while (i <=n-1):\n",
    "    j = 1\n",
    "    print(\"1\",end = '')\n",
    "    while (j<= i-1):\n",
    "        print(\"2\",end = '')\n",
    "        j +=1\n",
    "    print(\"1\", end = '')\n",
    "    print()\n",
    "    i +=1\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "11\n",
      "121\n",
      "1221\n",
      "12221\n",
      "122221\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 0\n",
    "while (i <n):\n",
    "    j = 0\n",
    "    while (j <i+1):\n",
    "        if(j ==0 or j ==i):\n",
    "            print(1,end='')\n",
    "        else:\n",
    "            print(2,end ='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i+=1\n",
    "    "
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "11\n",
      "121\n",
      "1221\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 9\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Number Pattern 3\n",
    "\n",
    "Print the following pattern for the given N number of rows.  \n",
    "Pattern for N = 4  \n",
    "1  \n",
    "11  \n",
    "202  \n",
    "3003    \n",
    "\n",
    "Input format :  \n",
    "Integer N (Total no. of rows)\n",
    "\n",
    "Contraints:  \n",
    "1 <= n <= 50\n",
    "\n",
    "Output format :  \n",
    "Pattern in N lines\n",
    "\n",
    "Sample Input :  \n",
    "5\n",
    "\n",
    "Sample Output :  \n",
    "1  \n",
    "11  \n",
    "202  \n",
    "3003  \n",
    "40004"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "print(\"1\")\n",
    "while (i <=n-1):\n",
    "    j = 1\n",
    "    print(i,end = '')\n",
    "    while (j<= i-1):\n",
    "        print(\"0\",end = '')\n",
    "        j +=1\n",
    "    print(i, end = '')\n",
    "    print()\n",
    "    i +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "11\n",
      "202\n",
      "3003\n",
      "40004\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "print('1')\n",
    "i = 1\n",
    "while (i <n):\n",
    "    j = 0\n",
    "    while (j <i+1):\n",
    "        if(j ==0 or j ==i):\n",
    "            print(i,end='')\n",
    "        else:\n",
    "            print(0,end ='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i+=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "11\n",
      "202\n",
      "3003\n",
      "40004\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 10"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Number Pattern\n",
    "\n",
    "Print the following pattern for the given N number of rows.  \n",
    "Pattern for N = 4  \n",
    "\n",
    "1234  \n",
    "123  \n",
    "12  \n",
    "1  \n",
    "\n",
    "Input format :  \n",
    "Integer N (Total no. of rows)\n",
    "\n",
    "Output format :  \n",
    "Pattern in N lines\n",
    "\n",
    "Sample Input :  \n",
    "5\n",
    "\n",
    "Sample Output :\n",
    "\n",
    "12345  \n",
    "1234  \n",
    "123  \n",
    "12  \n",
    "1  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\r\n",
    "i = 1\r\n",
    "while i<=n:\r\n",
    "    j = 1\r\n",
    "    while j<=(n-i+1):\r\n",
    "        print(j,end='') \r\n",
    "        j +=1\r\n",
    "    print()\r\n",
    "    i +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1234\n",
      "123\n",
      "12\n",
      "1\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Questoin 11"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Alpha Pattern\n",
    "\n",
    "Print the following pattern for the given N number of rows.  \n",
    "Pattern for N = 3  \n",
    "\n",
    " A  \n",
    " BB  \n",
    " CCC\n",
    "\n",
    "Input format :  \n",
    "Integer N (Total no. of rows)\n",
    "\n",
    "Output format :  \n",
    "Pattern in N lines\n",
    "\n",
    "Constraints  \n",
    "0 <= N <= 26\n",
    "\n",
    "Sample Input 1:  \n",
    "7\n",
    "\n",
    "Sample Output 1:  \n",
    "\n",
    "A  \n",
    "BB  \n",
    "CCC  \n",
    "DDDD  \n",
    "EEEEE  \n",
    "FFFFFF  \n",
    "GGGGGGG  \n",
    "\n",
    "Sample Input 2:  \n",
    "6\n",
    "\n",
    "Sample Output 2:  \n",
    "\n",
    "A  \n",
    "BB  \n",
    "CCC  \n",
    "DDDD  \n",
    "EEEEE  \n",
    "FFFFFF  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "while (i <=n):\n",
    "    start_char = chr(ord('A') + i -1)\n",
    "    j =1\n",
    "    while (j <=i):\n",
    "        print(start_char,end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "A\n",
      "BB\n",
      "CCC\n",
      "DDDD\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Patterns 2"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question1"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Code : Inverted Number Pattern\n",
    "\n",
    "Print the following pattern for the given N number of rows.\n",
    "\n",
    "Pattern for N = 4\n",
    "\n",
    "4444    \n",
    "333     \n",
    "22  \n",
    "1   "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "while (i <=n):\n",
    "    j = 1\n",
    "    while (j <=n -i +1):\n",
    "        print((n -i + 1),end ='')\n",
    "        j = j+1\n",
    "    print()\n",
    "    i += 1\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "4444\n",
      "333\n",
      "22\n",
      "1\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Reversed Triangle"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "'''\n",
    "   *\n",
    "  **\n",
    " ***\n",
    "****\n",
    "'''"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'\\n   *\\n  **\\n ***\\n****\\n'"
      ]
     },
     "metadata": {},
     "execution_count": 10
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\r\n",
    "i = 1\r\n",
    "while (i <= n):\r\n",
    "    spaces = 1\r\n",
    "    while spaces <= (n - i):\r\n",
    "        print(' ', end = '')\r\n",
    "        spaces +=1\r\n",
    "    \r\n",
    "    stars = 1\r\n",
    "    while stars <= i:\r\n",
    "        print('*', end ='')\r\n",
    "        stars +=1\r\n",
    "    print()\r\n",
    "    i += 1\r\n",
    "\r\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "   *\n",
      "  **\n",
      " ***\n",
      "****\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 2"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Code : Mirror Number Pattern\r\n",
    "\r\n",
    "Print the following pattern for the given N number of rows.\r\n",
    "Pattern for N = 4\r\n",
    "\r\n",
    "...1  \r\n",
    "..22  \r\n",
    ".333  \r\n",
    "4444  \r\n",
    "\r\n",
    "The dots represent spaces."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\r\n",
    "i = 1\r\n",
    "while (i <= n):\r\n",
    "    spaces = 1\r\n",
    "    while spaces <= (n - i):\r\n",
    "        print(' ', end = '')\r\n",
    "        spaces +=1\r\n",
    "    \r\n",
    "    stars = 1\r\n",
    "    while stars <= i:\r\n",
    "        print(i, end ='')\r\n",
    "        stars +=1\r\n",
    "    print()\r\n",
    "    i += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "   1\n",
      "  22\n",
      " 333\n",
      "4444\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Isoscelese Pattern Problems"
   ],
   "metadata": {}
  },
  {
   "cell_type": "raw",
   "source": [
    "   1\r\n",
    "  121\r\n",
    " 12321\r\n",
    "1234321\r\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# To bulid this first learn to build this\n",
    "'''\n",
    "   1\n",
    "  12\n",
    " 123\n",
    "1234\n",
    "'''"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# increasing sequence\n",
    "n = int(input())\n",
    "i = 1\n",
    "while (i <= n):\n",
    "    spaces = 1\n",
    "    while spaces <= (n - i):\n",
    "        print(' ', end = '')\n",
    "        spaces +=1\n",
    "    \n",
    "    j = 1\n",
    "    while j <= i:\n",
    "        print(j, end ='')\n",
    "        j +=1\n",
    "    print()\n",
    "    i += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "   1\n",
      "  12\n",
      " 123\n",
      "1234\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# decreasing sequence\n",
    "n = int(input())\n",
    "i = 2\n",
    "while(i<=n):\n",
    "    p = i -1\n",
    "    while p >= 1:\n",
    "        \n",
    "        print(p, end ='')\n",
    "        p -= 1\n",
    "    print()\n",
    "    i +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "21\n",
      "321\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "# Now for the actual Isoscelese Pattern\n",
    "n = int(input())\n",
    "i = 1\n",
    "while (i <= n):\n",
    "    # spaces\n",
    "    spaces = 1\n",
    "    while spaces <= (n - i):\n",
    "        print(' ', end = '')\n",
    "        spaces +=1\n",
    "    \n",
    "    # increasing sequence\n",
    "    j = 1\n",
    "    p = 1\n",
    "    while j <= i:\n",
    "        print(p, end ='')\n",
    "        j +=1\n",
    "        p +=1\n",
    "\n",
    "    # decreasing sequence \n",
    "    p = i -1\n",
    "    while p >= 1:\n",
    "        print(p, end ='')\n",
    "        p -= 1\n",
    "\n",
    "    print()\n",
    "    i += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "   1\n",
      "  121\n",
      " 12321\n",
      "1234321\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Queston 3"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "'''\n",
    "Print the following pattern\n",
    "Pattern for N = 4\n",
    "   *\n",
    "  ***\n",
    " *****\n",
    "*******\n",
    "The dots represent spaces.\n",
    "'''"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'\\nPrint the following pattern\\nPattern for N = 4\\n   *\\n  ***\\n *****\\n*******\\nThe dots represent spaces.\\n'"
      ]
     },
     "metadata": {},
     "execution_count": 5
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "n = int(input())\n",
    "i = 1\n",
    "while (i <=n):\n",
    "    space = 1\n",
    "    while (space <= n-i):\n",
    "        print(' ', end ='')\n",
    "        space += 1\n",
    "    \n",
    "    #increanmenting stars\n",
    "    stars = 1\n",
    "    while (stars <= i):\n",
    "        print('*',end ='')\n",
    "        stars += 1\n",
    "\n",
    "    #decrementing stars\n",
    "    p = i-1\n",
    "    while p >= 1:\n",
    "        print('*', end ='')\n",
    "        p -= 1\n",
    "    \n",
    "    print()\n",
    "    i += 1          \n",
    "\n",
    "    "
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "   *\n",
      "  ***\n",
      " *****\n",
      "*******\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 4"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "'''\n",
    "Editorial for the problem is present\n",
    "Code : Triangle of Numbers\n",
    "Print the following pattern for the given number of rows.\n",
    "Pattern for N = 4\n",
    "\n",
    "Sample Input 1:\n",
    "5\n",
    "\n",
    "Sample Output 1:\n",
    "      1\n",
    "     232\n",
    "    34543\n",
    "   4567654\n",
    "  567898765\n",
    "  '''\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# important see how p is used in the code\n",
    "n =  int(input())\n",
    "i = 1\n",
    "while (i <= n):\n",
    "    spaces =1\n",
    "    while (spaces <= n-i):\n",
    "        print(\" \", end='')\n",
    "        spaces += 1\n",
    "    \n",
    "    j = 1\n",
    "    p = i\n",
    "    while (j <= i):\n",
    "        print(p, end='')\n",
    "        p +=1\n",
    "        j +=1 \n",
    "    \n",
    "    k = 1\n",
    "    p = 2*i-2\n",
    "    while (k <= i-1):\n",
    "        print(p, end='')\n",
    "        k +=1\n",
    "        p -=1\n",
    "    print()\n",
    "    i +=1\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "   1\n",
      "  232\n",
      " 34543\n",
      "4567654\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "n = int(input()) \n",
    "currRow = 1 \n",
    "while currRow <= n:\n",
    "    spaces = 1 \n",
    "    while spaces <= (n - currRow) : \n",
    "        print(\" \", end = \"\") \n",
    "        spaces += 1 \n",
    "\n",
    "    currCol = 1\n",
    "    valToPrint = currRow \n",
    "    while currCol <= currRow : \n",
    "        print(valToPrint, end = \"\") \n",
    "        valToPrint += 1 \n",
    "        currCol += 1 \n",
    "        \n",
    "    currCol = 1 \n",
    "    valToPrint = 2 * currRow - 2 \n",
    "    while currCol <= currRow - 1 : \n",
    "        print(valToPrint, end = \"\") \n",
    "        valToPrint -= 1 \n",
    "        currCol += 1 \n",
    "    print() \n",
    "    currRow += 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "    1\n",
      "   232\n",
      "  34543\n",
      " 4567654\n",
      "567898765\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 5"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "'''\n",
    "Pyramid Number Pattern\n",
    "\n",
    "Print the following pattern for the given number of rows.\n",
    "Pattern for N = 4\n",
    "   1\n",
    "  212\n",
    " 32123\n",
    "4321234\n",
    "Input format : N (Total no. of rows)\n",
    "\n",
    "Output format : Pattern in N lines\n",
    "\n",
    "'''"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "n =  int(input())\n",
    "i = 1\n",
    "while (i <= n):\n",
    "    spaces =1\n",
    "    while (spaces <= n-i):\n",
    "        print(\" \", end='')\n",
    "        spaces += 1\n",
    "    \n",
    "    j = 1\n",
    "    p = i\n",
    "    while (j <= i):\n",
    "        print(p, end='')\n",
    "        p -=1\n",
    "        j +=1 \n",
    "    \n",
    "    k = 1\n",
    "    while (k <= i-1):\n",
    "        print(k+1, end='')\n",
    "        k +=1\n",
    "    print()\n",
    "    i +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "   1\n",
      "  212\n",
      " 32123\n",
      "4321234\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 6"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "'''\r\n",
    "Code : Diamond of stars\r\n",
    "Send Feedback\r\n",
    "Print the following pattern for the given number of rows.\r\n",
    "Note: N is always odd.\r\n",
    "\r\n",
    "\r\n",
    "Pattern for N = 5\r\n",
    "..*..\r\n",
    ".***.\r\n",
    "*****\r\n",
    ".***.\r\n",
    "..*..\r\n",
    "\r\n",
    "The dots represent spaces.\r\n",
    "'''"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "n = int(input())\r\n",
    "# top half\r\n",
    "n1 = (n+1)//2\r\n",
    "\r\n",
    "i = 1\r\n",
    "while i <= n1:\r\n",
    "    j = 1\r\n",
    "    #top spaces\r\n",
    "    while j <= n1 - i:\r\n",
    "        print(' ', end = '')\r\n",
    "        j +=1\r\n",
    "    \r\n",
    "    #top stars\r\n",
    "    k = 1\r\n",
    "    while k <= 2 * i - 1:\r\n",
    "        print('*',end = '')\r\n",
    "        k +=1   \r\n",
    "    i +=1\r\n",
    "    print()\r\n",
    "\r\n",
    "n2 = n//2\r\n",
    "y = 1\r\n",
    "while y <= n2:\r\n",
    "\r\n",
    "    #bottom spaces\r\n",
    "    l = 1\r\n",
    "    while l <= y:\r\n",
    "        print(' ',end = '')\r\n",
    "        l +=1\r\n",
    "\r\n",
    "    #bottom star\r\n",
    "    m = 1\r\n",
    "    while m <= n1+n2-2 * y :\r\n",
    "        print('*',end = '')\r\n",
    "        m +=1\r\n",
    "    \r\n",
    "    y +=1\r\n",
    "    print()\r\n",
    "    \r\n",
    "    "
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "   *\n",
      "  ***\n",
      " *****\n",
      "*******\n",
      " *****\n",
      "  ***\n",
      "   *\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "source": [
    "n = int(input()) \n",
    "firstHalf = (n + 1) // 2 \n",
    "secondHalf = n // 2 \n",
    "\n",
    "#First Half \n",
    "currRow = 1 \n",
    "while currRow <= firstHalf: \n",
    "    spaces = 1 \n",
    "    while spaces <= (firstHalf - currRow) : \n",
    "        print(\" \", end = \"\") \n",
    "        spaces += 1 \n",
    "\n",
    "    currCol = 1 \n",
    "    while currCol <= (2 * currRow) - 1 : \n",
    "        print(\"*\", end = \"\") \n",
    "        currCol += 1 \n",
    "        \n",
    "    print() \n",
    "    currRow += 1 \n",
    "#Second Half \n",
    "currRow = secondHalf \n",
    "while currRow >= 1 : \n",
    "    spaces = 1 \n",
    "    while spaces <= (secondHalf - currRow + 1) : \n",
    "        print(\" \", end = \"\") \n",
    "        spaces += 1 \n",
    "\n",
    "    currCol = 1 \n",
    "    while currCol <= (2 * currRow) - 1 : \n",
    "        print(\"*\", end = \"\") \n",
    "        currCol += 1 \n",
    "        \n",
    "    print() \n",
    "    currRow -= 1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "   *\n",
      "  ***\n",
      " *****\n",
      "*******\n",
      " *****\n",
      "  ***\n",
      "   *\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 7"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "'''\n",
    "Arrow pattern\n",
    "\n",
    "Print the following pattern for the given number of rows.\n",
    "Assume N is always odd.\n",
    "Note : There is space after every star.\n",
    "Pattern for N = 7\n",
    "*\n",
    " * *\n",
    "   * * *\n",
    "     * * * *\n",
    "   * * *\n",
    " * *\n",
    "*\n",
    "'''"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "source": [
    "n = int(input())\n",
    "n1 = (n+1)//2\n",
    "n2 = n//2\n",
    "\n",
    "i = 1\n",
    "while (i <= n1):\n",
    "    #top half spaces\n",
    "    j = 1\n",
    "    while (j <= i-1):\n",
    "        print(' ', end =\"\")\n",
    "        j +=1\n",
    "    \n",
    "    #top half stars\n",
    "    k = 1\n",
    "    while (k <=i):\n",
    "        print('* ', end =\"\")\n",
    "        k+=1\n",
    "    print()\n",
    "    i +=1\n",
    "\n",
    "y = 1\n",
    "while (y <= n2):\n",
    "    #top half spaces\n",
    "    j = 1\n",
    "    while (j <= n2 -y):\n",
    "        print(' ', end =\"\")\n",
    "        j +=1\n",
    "    \n",
    "    #top half stars\n",
    "    k = 1\n",
    "    while (k <=n2 -y+1):\n",
    "        print('* ', end =\"\")\n",
    "        k +=1\n",
    "    print()\n",
    "    y +=1\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "* \n",
      " * * \n",
      "  * * * \n",
      "   * * * * \n",
      "  * * * \n",
      " * * \n",
      "* \n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 8"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<pre>\r\n",
    "Number Patternn = int(input())\r\n",
    "startValue = 1\r\n",
    "\r\n",
    "for row in range(1, n + 1):\r\n",
    "    \r\n",
    "    # Declaring a string to store our row in the pattern\r\n",
    "    ans = \"\"\r\n",
    "    \r\n",
    "    # Appending value of each column of each row in ans\r\n",
    "\r\n",
    "    for col in range(startValue, startValue + n):\r\n",
    "        \r\n",
    "        ans += str(col) + \" \"\r\n",
    "        \r\n",
    "    # 'col' represents our current columnn in our current row\r\n",
    "    \r\n",
    "    if (row == (n + 1) // 2):\r\n",
    "        if (n % 2 != 0):\r\n",
    "            \r\n",
    "            startValue = n * (n - 2) + 1\r\n",
    "            \r\n",
    "        else:\r\n",
    "            startValue = n * (n - 1) + 1\r\n",
    "            \r\n",
    "    elif (row > (n + 1) // 2):\r\n",
    "        startValue = startValue - 2 * n\r\n",
    "        \r\n",
    "    else:\r\n",
    "        startValue = startValue + 2 * n\r\n",
    "\r\n",
    "print(ans)\r\n",
    "\r\n",
    "Print the following pattern for n number of rows.\r\n",
    "For eg. N = 5\r\n",
    "\r\n",
    "1        1\r\n",
    "12      21\r\n",
    "123    321\r\n",
    "1234  4321\r\n",
    "</pre>"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "n = int(input())\r\n",
    "i = 1\r\n",
    "while(i <=n):\r\n",
    "    # starting numbers\r\n",
    "    j = 1\r\n",
    "    while(j <=i):\r\n",
    "        print(j,end= '')\r\n",
    "        j +=1\r\n",
    "\r\n",
    "    # spaces\r\n",
    "    k = 1\r\n",
    "    while(k <=2*n-2*i):\r\n",
    "        print(' ',end= '')\r\n",
    "        k +=1\r\n",
    "    \r\n",
    "    # ending spaces\r\n",
    "    l = 1\r\n",
    "    p = i\r\n",
    "    while(l <= i):\r\n",
    "        print(p,end= '')\r\n",
    "        p -=1\r\n",
    "        l +=1\r\n",
    "        \r\n",
    "    print()\r\n",
    "    i +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1        1\n",
      "12      21\n",
      "123    321\n",
      "1234  4321\n",
      "1234554321\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "# Editorial Answer\r\n",
    "n= int (input()) \r\n",
    "totalspace=n*2-2 \r\n",
    "row=1 \r\n",
    "while(row<=n): \r\n",
    "    column=1 \r\n",
    "    while(column<=row): \r\n",
    "        print(column,end='') \r\n",
    "        column=column+1 \r\n",
    "        \r\n",
    "    space=1 \r\n",
    "    while(space<=totalspace): \r\n",
    "        print(\" \",end='') \r\n",
    "        space=space+1 \r\n",
    "    \r\n",
    "    totalspace=totalspace-2 \r\n",
    "        \r\n",
    "    column=row \r\n",
    "    while(column>0): \r\n",
    "        print(column, end='') \r\n",
    "        column=column-1 \r\n",
    "    row=row+1 \r\n",
    "    print()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1        1\n",
      "12      21\n",
      "123    321\n",
      "1234  4321\n",
      "1234554321\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<pre>\r\n",
    "Zeros and Stars Pattern\r\n",
    "\r\n",
    "Print the following pattern\r\n",
    "Pattern for N = 4\r\n",
    "\r\n",
    "*000*000*\r\n",
    "0*00*00*0\r\n",
    "00*0*0*00\r\n",
    "000***000\r\n",
    "\r\n",
    "Input Format :\r\n",
    "N (Total no. of rows)\r\n",
    "Output Format :\r\n",
    "Pattern in N lines\r\n",
    "Sample Input 1 :\r\n",
    "3\r\n",
    "Sample Output 1 :\r\n",
    "\r\n",
    "*00*00*\r\n",
    "0*0*0*0\r\n",
    "00***00\r\n",
    "\r\n",
    "Sample Input 2 :\r\n",
    "5\r\n",
    "Sample Output 2 :\r\n",
    "\r\n",
    "*0000*0000*\r\n",
    "0*000*000*0\r\n",
    "00*00*00*00\r\n",
    "000*0*0*000\r\n",
    "0000***0000\r\n",
    "</pre>"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "# TODO\r\n",
    "n = int(input())  \r\n",
    "i=1  \r\n",
    "j=1  \r\n",
    "while i<=n:  #this loop is used to print n  \r\n",
    "    j=1  \r\n",
    "    while j<=n:      #this loop is used to print lines  \r\n",
    "        if i==j:  \r\n",
    "            print(\"*\", end='')  \r\n",
    "        else :  \r\n",
    "            print(\"0\", end='')  \r\n",
    "        j=j+1  \r\n",
    "        \r\n",
    "    j=j-1;  \r\n",
    "    print(\"*\", end='')  \r\n",
    "    while j>=1:  #this loop is used to print lines  \r\n",
    "        if i==j:  \r\n",
    "            print(\"*\", end='')  \r\n",
    "        else :  \r\n",
    "            print(\"0\", end='')  \r\n",
    "        j=j-1  \r\n",
    "    print(\"\");  \r\n",
    "    i=i+1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "*000*000*\n",
      "0*00*00*0\n",
      "00*0*0*00\n",
      "000***000\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## More on loops"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Generic Code for understanding"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "s = 'abcd'\n",
    "for c in s:\n",
    "    print(c)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "# print number from 1 to n\n",
    "n = int(input())\n",
    "for i in range(1,n + 1,1):\n",
    "    print (i)\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "source": [
    "\n",
    "n = int(input())\n",
    "for i in range(n, 0,-1):\n",
    "    print (i)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 1"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "print all numbers form a to b which are multiples of 3. Assume a < b"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "source": [
    "# approach 1\r\n",
    "a = int(input())\r\n",
    "b = int(input())\r\n",
    "for i in range(a,b+1,1):\r\n",
    "    if (i %3 == 0):\r\n",
    "        print(i, end = ' ')\r\n",
    "# This loop will run n times to execute the result"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "102 105 108 111 114 117 120 123 126 129 "
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "source": [
    "#approach 2\r\n",
    "a = int(input())\r\n",
    "b = int(input())\r\n",
    "\r\n",
    "if a % 3 ==0:\r\n",
    "    s = a\r\n",
    "if a % 3 ==1:\r\n",
    "    s = a+2\r\n",
    "if a % 3==2:\r\n",
    "    s = a+1\r\n",
    "\r\n",
    "for i in range(s,b+1,3):\r\n",
    "    if (i %3 == 0):\r\n",
    "        print(i, end = ' ')\r\n",
    "\r\n",
    "# Although we have written more code than approach one we are able to see better results as running time is less as it is not running n times.\r\n",
    "# it is running n/3 times as it has a step of 3 which means it is approximately 3 times faster"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "6 9 12 15 18 21 24 27 30 33 36 39 42 45 48 51 54 "
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 2"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Check if a number is prime or not"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "source": [
    "n = int(input())\r\n",
    "flag = False\r\n",
    "for d in range(2,n,1): # we are using n as stop because we want to check form 2 to (n - 1)\r\n",
    "    if n % d ==0:\r\n",
    "        flag = True\r\n",
    "if flag == True: # we could also have written 'if flag' , it would have meant the same thing \r\n",
    "    print(n,\"not is prime\")\r\n",
    "else:\r\n",
    "    print(n, \"prime\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "7 prime\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Patetrn uisng for"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "source": [
    "n = int(input())\r\n",
    "for i in range(1, n+1): # 1 till n equwalent to while i<=n\r\n",
    "    # spaces\r\n",
    "    # we did not write n-2 at stop because we are starting at 0, and 0 is default \r\n",
    "    # so if we wanted we could have written raneg(n-i) or range(1,n-i+1) - one further from where we wat to stop.\r\n",
    "    for s in range(0, n-i):\r\n",
    "        print(' ', end = '')\r\n",
    "    # stars\r\n",
    "\r\n",
    "    #increase\r\n",
    "    for c in range(i, 2*i,1):\r\n",
    "        print(c, end = '')\r\n",
    "    \r\n",
    "    #decreaing\r\n",
    "    for v in range(2*i-2,i-1,-1):\r\n",
    "        print(v, end = '')\r\n",
    "    print()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "   1\n",
      "  232\n",
      " 34543\n",
      "4567654\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Break Statements"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "i  = 1\n",
    "while i < 10:\n",
    "    if i == 5:\n",
    "        break\n",
    "    print(i)\n",
    "    i +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "n = int(input())\n",
    "d = 2 \n",
    "flag = False\n",
    "while(d < n):\n",
    "    if (n%d==0):\n",
    "        flag = True\n",
    "        break\n",
    "    d += 1\n",
    "\n",
    "if flag:\n",
    "    print('not prime')\n",
    "else:\n",
    "    print('prime')\n",
    "\n",
    "# This is better than the code we wrote before as we are able to break out when we see even one number n is divisible bt so th while loop runs less amount of time. Therefore it is optimeised"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "not prime\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "# break works the same way in for as in while\n",
    "n = int(input())\n",
    "flag = False\n",
    "for d in range(2,n,1): # we are using n as stop because we want to check form 2 to (n - 1)\n",
    "    if n % d ==0:\n",
    "        flag = True\n",
    "        break\n",
    "if flag == True: # we could also have written 'if flag' , it would have meant the same thing \n",
    "    print(n,\"not is prime\")\n",
    "else:\n",
    "    print(n, \"prime\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "123488 not is prime\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "# if there is inner while loop and a break is inside it it will only break the inner while loop.\r\n",
    "n =  int(input())\r\n",
    "k = 2\r\n",
    "while(k<=n):\r\n",
    "    d = 2\r\n",
    "    flag = False\r\n",
    "    while(d<k):\r\n",
    "        if k % d == 0:\r\n",
    "            flag = True\r\n",
    "            break\r\n",
    "        d += 1\r\n",
    "    if(not(flag)):\r\n",
    "        print(k)\r\n",
    "    k +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2\n",
      "3\n",
      "5\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Else in while and for loops"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "# else in while loops \r\n",
    "i =1\r\n",
    "while(i <10):\r\n",
    "    print(i)\r\n",
    "    i += 1\r\n",
    "else:\r\n",
    "    print('This will be printed in once in the end')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "This will be printed in once in the end\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "# else in for loop\r\n",
    "for i in range(1, 10 ):\r\n",
    "    print(i)\r\n",
    "else:\r\n",
    "    print('This will be printed once in the end')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "This will be printed once in the end\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "source": [
    "# if the code is broken by the break statement then the code will not go inside the else statement\n",
    "i =1\n",
    "for i in range(1, 10 ):\n",
    "    if( i == 5):\n",
    "        break\n",
    "    print(i)\n",
    "else:\n",
    "    print('This will be printed once in the end')\n",
    "\n",
    "# does not print the contents of elso statement"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "source": [
    "# To check if the number is prime\n",
    "n = int(input())\n",
    "\n",
    "for d in range(2,n,1): \n",
    "    if n % d ==0:\n",
    "        break\n",
    "# we will only go inside else if nothing could divide n\n",
    "else: \n",
    "    print(n, 'is a Prime Number')\n",
    "\n",
    "# it is better than the previous as we do not have to use if statements and make flags\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "13 is a Prime Number\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Continue Statement"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "source": [
    "for i in range(1, 11):\n",
    "    if i == 5:\n",
    "        continue\n",
    "    print(i)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "source": [
    "# If we had to do a certain task for only odd number but also wanted to print all the numbers we could do this using continue\n",
    "for i in range(1, 20):\n",
    "    #print(i)\n",
    "    if(i%2 ==0):\n",
    "        continue\n",
    "    print(i)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n",
      "11\n",
      "13\n",
      "15\n",
      "17\n",
      "19\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "source": [
    "# Print all even number exept which are multiple of 7\n",
    "n = int(input())\n",
    "for i in range(2, n+1, 2):\n",
    "    if i % 7 == 0:\n",
    "        continue\n",
    "    print(i, end=' ')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2 4 6 8 10 12 16 18 20 22 24 26 30 32 34 36 38 40 "
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "source": [
    "# continue in case of a while loop\n",
    "n = int(input())\n",
    "i = 2\n",
    "while i <= n:\n",
    "    if i % 7 == 0:\n",
    "        i +=2       # we have to put an increment here as in while continue is also skipping the i +=2 which is written at the bottom, so we ahve to write it inside the intend\n",
    "        continue\n",
    "    print(i)\n",
    "    i += 2"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "16\n",
      "18\n",
      "20\n",
      "22\n",
      "24\n",
      "26\n",
      "30\n",
      "32\n",
      "34\n",
      "36\n",
      "38\n",
      "40\n",
      "44\n",
      "46\n",
      "48\n",
      "50\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Pass Statement"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "source": [
    "# dummy statement if we do not want to write anything inside the loop\n",
    "i = 1\n",
    "if i <7:\n",
    "    pass\n",
    "print(\" skipped the if statement\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      " skipped the if statement\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "source": [
    "i = 1\n",
    "while i<= 3:\n",
    "    pass\n",
    "    i +=1\n",
    "print('passed the while statement')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "passed the while statement\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "source": [
    "for i in range(1, 10):\n",
    "    pass\n",
    "print('passed the for loop')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "passed the for loop\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Questoin 3"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "'''\n",
    "Binary Pattern\n",
    "\n",
    "Print the following pattern for the given number of rows.\n",
    "Pattern for N = 4\n",
    "1111\n",
    "000\n",
    "11\n",
    "0\n",
    "Input format : N (Total no. of rows)\n",
    "\n",
    "Output format : Pattern in N lines\n",
    "'''"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "n=int(input())\n",
    "for i in range(1,n+1):\n",
    "    for k in range(1,n-i+2):\n",
    "        if i %2!=0:\n",
    "            print(1,end=\"\")\n",
    "        else:\n",
    "            print(0,end=\"\")\n",
    "    print()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1111\n",
      "000\n",
      "11\n",
      "0\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "n = int(input())\r\n",
    "i = 1\r\n",
    "while i <=n:\r\n",
    "    k = 1\r\n",
    "    while k <= n-i+1:\r\n",
    "        if i %2!=0:\r\n",
    "            print(1,end=\"\")\r\n",
    "        else:\r\n",
    "            print(0,end=\"\")\r\n",
    "        k +=1\r\n",
    "    print()\r\n",
    "    i +=1"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1111\n",
      "000\n",
      "11\n",
      "0\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 4"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "'''\r\n",
    "Print Number Pyramid  \r\n",
    "\r\n",
    "Print the following pattern for a given n.  \r\n",
    "For eg. N = 6   \r\n",
    "\r\n",
    "123456  \r\n",
    " 23456  \r\n",
    "  3456  \r\n",
    "   456  \r\n",
    "    56  \r\n",
    "     6  \r\n",
    "    56  \r\n",
    "   456  \r\n",
    "  3456  \r\n",
    " 23456  \r\n",
    "123456 \r\n",
    "'''"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "source": [
    "n = int(input())\r\n",
    "n1 = n\r\n",
    "n2 = n - 1\r\n",
    "\r\n",
    "# Top half\r\n",
    "i = 1\r\n",
    "while i<=n1:\r\n",
    "    # top spaces\r\n",
    "    j = 1\r\n",
    "    while j<= i -1:\r\n",
    "        print(' ',end ='')\r\n",
    "        j +=1\r\n",
    "    \r\n",
    "    # top num\r\n",
    "    k = 1\r\n",
    "    p = i\r\n",
    "    while k <=n1 -i+1:\r\n",
    "        print(p,end='')\r\n",
    "        k+=1\r\n",
    "        p +=1\r\n",
    "    print()\r\n",
    "    i+=1\r\n",
    "    \r\n",
    "y = 1\r\n",
    "while y<=n2:\r\n",
    "    # top spaces\r\n",
    "    j = 1\r\n",
    "    while j<= n2 -y:\r\n",
    "        print(' ',end ='')\r\n",
    "        j +=1\r\n",
    "    \r\n",
    "    # top num\r\n",
    "    k = 1\r\n",
    "    p = n2 -y +1\r\n",
    "    while k <=y +1:\r\n",
    "        print(p,end='')\r\n",
    "        k+=1\r\n",
    "        p+=1\r\n",
    "    \r\n",
    "    print()\r\n",
    "    y +=1\r\n",
    "    \r\n",
    "  \r\n",
    "    "
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1234\n",
      " 234\n",
      "  34\n",
      "   4\n",
      "  34\n",
      " 234\n",
      "1234\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 5"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Rectangular numbers    \n",
    "\n",
    "Print the following pattern for the given number of rows.  \n",
    "Pattern for N = 4   \n",
    "4444444  \n",
    "4333334  \n",
    "4322234  \n",
    "4321234  \n",
    "4322234  \n",
    "4333334  \n",
    "4444444  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "## unable to do copy from the interner change later after understanding\n",
    "n= int(input())\n",
    "answer=[[1]]\n",
    "for i in range(2, n+1):\n",
    "    t=[i]*((2*i)-3)\n",
    "    answer.insert(0, t)\n",
    "    answer.append(t.copy())\n",
    "    for a in answer:\n",
    "        a.insert(0,i)\n",
    "        a.append(i)\n",
    "answerfinal=[]\n",
    "for a in answer:\n",
    "    answerfinal.append(str(a).replace(' ','').replace(',','').replace(']','').replace('[',''))\n",
    "for a in answerfinal:\n",
    "    print(a)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "555555555\n",
      "544444445\n",
      "543333345\n",
      "543222345\n",
      "543212345\n",
      "543222345\n",
      "543333345\n",
      "544444445\n",
      "555555555\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "# solution seen\n",
    "n = int(input()) \n",
    "for i in range(1,n+1): \n",
    "    temp = n \n",
    "    for j in range(1,i): \n",
    "        print(temp,end=\"\") \n",
    "        temp = temp -1 \n",
    "    \n",
    "    for j in range(1,(2*n) - (2*i) + 2): \n",
    "        print(n-i+1,end=\"\") \n",
    "        \n",
    "    for j in range(1,i): \n",
    "        temp = temp+1 \n",
    "        print(temp,end=\"\") \n",
    "    print() \n",
    "    \n",
    "for i in range(n-1,0,-1): \n",
    "    temp = n \n",
    "    for j in range(1,i): \n",
    "        print(temp,end=\"\") \n",
    "        temp = temp - 1 \n",
    "        \n",
    "    for j in range(1,(2*n) - (2*i) + 2): \n",
    "        print(n-i+1,end=\"\") \n",
    "        \n",
    "    for j in range(1,i): \n",
    "        temp = temp+1 \n",
    "        print(temp,end=\"\") \n",
    "    print()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "555555555\n",
      "544444445\n",
      "543333345\n",
      "543222345\n",
      "543212345\n",
      "543222345\n",
      "543333345\n",
      "544444445\n",
      "555555555\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 6"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "source": [
    "'''\r\n",
    "    Time Complexity: O(N ^ 2)\r\n",
    "    Space Complexity: O(N ^ 2)\r\n",
    "\r\n",
    "    Where N is the given number of rows.\r\n",
    "'''\r\n",
    "\r\n",
    "def printPattern(n):\r\n",
    "\r\n",
    "\t# Declaring a vector of string for storing the pattern\r\n",
    "\tresult = []\r\n",
    "\t\r\n",
    "\t# Keeping track of the start value of each row\r\n",
    "\t \r\n",
    "\tstartValue = 1\r\n",
    "\r\n",
    "\tfor row in range(1, n + 1):\r\n",
    "\t\t\r\n",
    "\t\t# Declaring a string to store our row in the pattern\r\n",
    "\t\tans = \"\"\r\n",
    "\t\t\r\n",
    "\t\t# Appending value of each column of each row in ans\r\n",
    "\r\n",
    "\t\tfor col in range(startValue, startValue + n):\r\n",
    "\t\t\t\r\n",
    "\t\t\tans += str(col) + \" \"\r\n",
    "\t\t\t\r\n",
    "\t\t# 'col' represents our current columnn in our current row\r\n",
    "\t\t\r\n",
    "\t\tif (row == (n + 1) // 2):\r\n",
    "\t\t\tif (n % 2 != 0):\r\n",
    "\t\t\t\t\r\n",
    "\t\t\t\tstartValue = n * (n - 2) + 1\r\n",
    "\t\t\t\t\r\n",
    "\t\t\telse:\r\n",
    "\t\t\t\tstartValue = n * (n - 1) + 1\r\n",
    "\t\t\t\t\r\n",
    "\t\telif (row > (n + 1) // 2):\r\n",
    "\t\t\tstartValue = startValue - 2 * n\r\n",
    "\t\t\t\r\n",
    "\t\telse:\r\n",
    "\t\t\tstartValue = startValue + 2 * n\r\n",
    "\t\t\t\r\n",
    "\t\t\t\r\n",
    "\t\tresult.append(ans)\r\n",
    "\t\t\r\n",
    "\t\t\r\n",
    "\treturn result"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "source": [
    "n = int(input())\r\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "5 6 7 8 \n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 7"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "'''\r\n",
    "Code : Diamond of stars\r\n",
    "Send Feedback\r\n",
    "Print the following pattern for the given number of rows.\r\n",
    "Note: N is always odd.\r\n",
    "\r\n",
    "\r\n",
    "Pattern for N = 5\r\n",
    "..*..\r\n",
    ".***.\r\n",
    "*****\r\n",
    ".***.\r\n",
    "..*..\r\n",
    "\r\n",
    "The dots represent spaces.\r\n",
    "'''"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# conver the code into for loops TODO\r\n",
    "n = int(input())\r\n",
    "# top half\r\n",
    "n1 = (n+1)//2\r\n",
    "\r\n",
    "i = 1\r\n",
    "while i <= n1:\r\n",
    "    j = 1\r\n",
    "    #top spaces\r\n",
    "    while j <= n1 - i:\r\n",
    "        print(' ', end = '')\r\n",
    "        j +=1\r\n",
    "    \r\n",
    "    #top stars\r\n",
    "    k = 1\r\n",
    "    while k <= 2 * i - 1:\r\n",
    "        print('*',end = '')\r\n",
    "        k +=1   \r\n",
    "    i +=1\r\n",
    "    print()\r\n",
    "\r\n",
    "n2 = n//2\r\n",
    "y = 1\r\n",
    "while y <= n2:\r\n",
    "\r\n",
    "    #bottom spaces\r\n",
    "    l = 1\r\n",
    "    while l <= y:\r\n",
    "        print(' ',end = '')\r\n",
    "        l +=1\r\n",
    "\r\n",
    "    #bottom star\r\n",
    "    m = 1\r\n",
    "    while m <= n1+n2-2 * y :\r\n",
    "        print('*',end = '')\r\n",
    "        m +=1\r\n",
    "    \r\n",
    "    y +=1\r\n",
    "    print()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question 8"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<pre>\r\n",
    "Print the pattern\r\n",
    "\r\n",
    "Print the following pattern for the given number of rows.\r\n",
    "Pattern for N = 5\r\n",
    " 1    2   3    4   5\r\n",
    " 11   12  13   14  15\r\n",
    " 21   22  23   24  25\r\n",
    " 16   17  18   19  20\r\n",
    " 6    7    8   9   10\r\n",
    "Input format : N (Total no. of rows)\r\n",
    "\r\n",
    "Output format : Pattern in N lines\r\n",
    "\r\n",
    "Sample Input :\r\n",
    "4\r\n",
    "Sample Output :\r\n",
    " 1  2  3  4\r\n",
    " 9 10 11 12\r\n",
    "13 14 15 16\r\n",
    " 5  6  7  8\r\n",
    "</pre>"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [],
   "outputs": [],
   "metadata": {}
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "96eb50e1d44aed467dc8f759cb08c32fbfa9babcf79c554e2d0e5feb04653a10"
  },
  "kernelspec": {
   "display_name": "Python 3.8.8 64-bit ('base': conda)",
   "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"
  },
  "orig_nbformat": 2
 },
 "nbformat": 4,
 "nbformat_minor": 2
}