Patterns.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Patterns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 6\n",
      "Number of Columns:- 8\n",
      "\n",
      "********\n",
      "*      *\n",
      "*      *\n",
      "********\n",
      "*      *\n",
      "*      *\n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col == 0 or col == n-1) or ((row==0 or row==int(m/2)) and (col>0 or col< (n-1))):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(' ',end=\"\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 6\n",
      "Number of Columns:- 7\n",
      "\n",
      " ***** \n",
      "*     *\n",
      "*     *\n",
      "*******\n",
      "*     *\n",
      "*     *\n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if ((col == 0 or col == n-1) and row!=0) or ((row==0 or row==int(m/2)) and (col>0 and col< (n-1))):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(' ',end=\"\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 7\n",
      "Number of Columns:- 7\n",
      "\n",
      "*******\n",
      "*     *\n",
      "*     *\n",
      "*******\n",
      "*     *\n",
      "*     *\n",
      "*******\n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col == 0 or col == n-1) or ((row==0 or row==int(m/2) or row == (m-1)) and (col>0 or col< (n-1))):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 6\n",
      "Number of Columns:- 7\n",
      "\n",
      "****** \n",
      "*     *\n",
      "*     *\n",
      "*******\n",
      "*     *\n",
      "****** \n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col == 0 or ((col == n-1) and (row!=0 and row!=m-1))) or ((row==0 or row==int(m/2) or row == (m-1)) and (col>0 and col< (n-1))):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 5\n",
      "Number of Columns:- 6\n",
      "\n",
      "******\n",
      "*     \n",
      "*     \n",
      "*     \n",
      "******\n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col == 0) or ((row==0 or row==(m-1)) and (col!=0)):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 6\n",
      "Number of Columns:- 7\n",
      "\n",
      " ******\n",
      "*      \n",
      "*      \n",
      "*      \n",
      "*      \n",
      " ******\n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col == 0 and (row!=0 and row!=(m-1))) or ((row==0 or row==(m-1)) and (col!=0)):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### print D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 6\n",
      "Number of Columns:- 7\n",
      "\n",
      "****** \n",
      "*     *\n",
      "*     *\n",
      "*     *\n",
      "*     *\n",
      "****** \n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col==0) or ((col==n-1) and (row!=0 and row != m-1)) or ((row==0 or row ==m-1) and (col > 0 and col <n-1)):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 9\n",
      "Number of Columns:- 8\n",
      "\n",
      "********\n",
      "*       \n",
      "*       \n",
      "*       \n",
      "********\n",
      "*       \n",
      "*       \n",
      "*       \n",
      "********\n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col == 0) or ((row==0 or row==m-1 or row ==int(m/2)) and (col !=0)):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 9\n",
      "Number of Columns:- 6\n",
      "\n",
      "******\n",
      "*     \n",
      "*     \n",
      "*     \n",
      "******\n",
      "*     \n",
      "*     \n",
      "*     \n",
      "*     \n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col == 0) or ((row==0 or row ==int(m/2)) and (col !=0)):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 9\n",
      "Number of Columns:- 7\n",
      "\n",
      "****** \n",
      "*      \n",
      "*      \n",
      "*      \n",
      "*  ****\n",
      "*    * \n",
      "*    * \n",
      "*    * \n",
      "****** \n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col == 0) or ((row==0 or row==m-1) and (col > 0 and col < n-1)) or (row==int(m/2) and (col>=int(n/2)) ) or (col==n-2 and row >= int(m/2)):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 7\n",
      "Number of Columns:- 6\n",
      "\n",
      "*    *\n",
      "*    *\n",
      "*    *\n",
      "******\n",
      "*    *\n",
      "*    *\n",
      "*    *\n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col == 0 or col==n-1) or ((row==int(m/2)) and (col>0 and col < n-1)):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 7\n",
      "Number of Columns:- 9\n",
      "\n",
      "*********\n",
      "    *    \n",
      "    *    \n",
      "    *    \n",
      "    *    \n",
      "    *    \n",
      "*********\n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (row==0 or row==m-1) or ((col==int(n/2)) and (row>0 and row<m-1)):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print J"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 6\n",
      "Number of Columns:- 7\n",
      "\n",
      "*******\n",
      "   *   \n",
      "   *   \n",
      "   *   \n",
      "   *   \n",
      "****   \n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (row==0 or ((row==m-1) and col < (n/2))) or ((col==int(n/2)) and (row>0 and row<m-1)):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 6\n",
      "Number of Columns:- 9\n",
      "\n",
      "*        \n",
      "*        \n",
      "*        \n",
      "*        \n",
      "*        \n",
      "*********\n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col == 0) or (row==m-1 and col > 0):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 7\n",
      "Number of Columns:- 9\n",
      "\n",
      " ******* \n",
      "*       *\n",
      "*       *\n",
      "*       *\n",
      "*       *\n",
      "*       *\n",
      " ******* \n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col==0 and (row>0 and row <m-1)) or ((col==n-1) and (row!=0 and row != m-1)) or ((row==0 or row ==m-1) and (col > 0 and col <n-1)):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 8\n",
      "Number of Columns:- 7\n",
      "\n",
      "****** \n",
      "*     *\n",
      "*     *\n",
      "*     *\n",
      "****** \n",
      "*      \n",
      "*      \n",
      "*      \n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (col==0) or ((row==0 or row ==(int(m/2))) and (col>0 and col<n-1)) or (col==n-1 and (row>0 and row < int(m/2))):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print Q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 7\n",
      "Number of Columns:- 9\n",
      "\n",
      "*********\n",
      "    *    \n",
      "    *    \n",
      "    *    \n",
      "    *    \n",
      "    *    \n",
      "         \n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if (row==0) or ((col==int(n/2)) and (row>0 and row<m-1)):\n",
    "            print('*',end=\"\")\n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of rows:- 7\n",
      "Number of Columns:- 8\n",
      "\n",
      "*      *\n",
      "*      *\n",
      "*      *\n",
      "*      *\n",
      "*      *\n",
      "*      *\n",
      " ****** \n"
     ]
    }
   ],
   "source": [
    "m,n= int(input('Enter Number of rows:- ')),int(input('Number of Columns:- '))\n",
    "print()\n",
    "for row in range(m):\n",
    "    for col in range(n):\n",
    "        if ((col==0 or col ==n-1) and (row!=m-1) ) or (row==m-1 and (col>0 and col <n-1)) :\n",
    "            print('*',end=\"\") \n",
    "        else:\n",
    "            print(end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print W"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some Interesting Patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 9\n",
      "1\n",
      "22\n",
      "333\n",
      "4444\n",
      "55555\n",
      "666666\n",
      "7777777\n",
      "88888888\n",
      "999999999\n"
     ]
    }
   ],
   "source": [
    "# Simple Number Triangle Pattern\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n): \n",
    "    for j in range(i+1):\n",
    "        print(i+1,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 5\n",
      "11111\n",
      "2222\n",
      "333\n",
      "44\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Inverted Pyramid of Numbers\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(n-i):\n",
    "        print(i+1,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 5\n",
      "1\n",
      "12\n",
      "123\n",
      "1234\n",
      "12345\n"
     ]
    }
   ],
   "source": [
    "# Half Pyramid Pattern of Numbers\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(1,n+1):\n",
    "    for j in range(i):\n",
    "        print(j+1,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 5\n",
      "55555\n",
      "4444\n",
      "333\n",
      "22\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Inverted Pyramid of Descending Numbers\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(n-i):\n",
    "        print(n-i,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 5\n",
      "55555\n",
      "5555\n",
      "555\n",
      "55\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Inverted Pyramid of the Same Digit\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(n-i):\n",
    "        print(n,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 5\n",
      "1\n",
      "21\n",
      "321\n",
      "4321\n",
      "54321\n"
     ]
    }
   ],
   "source": [
    "# Reverse Pyramid of Numbers\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(i+1,0,-1):\n",
    "        print(j,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 5\n",
      "54321\n",
      "4321\n",
      "321\n",
      "21\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Inverted half Pyramid of Numbers\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(n-i,0,-1):\n",
    "        print(j,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 5\n",
      "01234\n",
      "0123\n",
      "012\n",
      "01\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "# Inverted half Pyramid of Numbers\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(n-i): \n",
    "        print(j,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter starting Number:- 1\n",
      "Enter step increment size:- 2\n",
      "How many rows :- 3\n",
      "1\n",
      "234\n",
      "56789\n"
     ]
    }
   ],
   "source": [
    "# Inverted half Pyramid of Numbers\n",
    "start = int(input('Enter starting Number:- '))\n",
    "stop =  int(input('Enter step increment size:- '))\n",
    "rows = int(input('How many rows :- '))\n",
    "cnt=1\n",
    "for i in range(rows):\n",
    "    for j in range(1,stop):\n",
    "        print(start,end='')\n",
    "        start+=1\n",
    "    stop+=2\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 6\n",
      "1\n",
      "121\n",
      "12321\n",
      "1234321\n",
      "123454321\n",
      "12345654321\n"
     ]
    }
   ],
   "source": [
    "# Unique Pyramid Pattern of Digits\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(i):\n",
    "        print(j+1,end='')\n",
    "    for j in range(i+1,0,-1):\n",
    "        print(j,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 8\n",
      "sa \n",
      "sa re sa \n",
      "sa re ga re sa \n",
      "sa re ga ma ga re sa \n",
      "sa re ga ma pa ma ga re sa \n",
      "sa re ga ma pa dha pa ma ga re sa \n",
      "sa re ga ma pa dha ni dha pa ma ga re sa \n",
      "sa re ga ma pa dha ni sa ni dha pa ma ga re sa \n"
     ]
    }
   ],
   "source": [
    "# Indian Classical Music\n",
    "n = int(input('Enter size:- '))\n",
    "music = ['sa' , 're' , 'ga', 'ma', 'pa' , 'dha' , 'ni', 'sa' ] \n",
    "if n > len(music):\n",
    "    print('Invalid Input')\n",
    "else:\n",
    "    for i in range(n):\n",
    "        for j in range(i+1):\n",
    "            print(music[j]+' ',end='') \n",
    "        for j in range(i-1,-1,-1):\n",
    "            print(music[j]+' ',end='')\n",
    "        print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 5\n",
      "5432112345\n",
      "54322345\n",
      "543345\n",
      "5445\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "# Connected Inverted Pyramid Pattern of Numbers\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(n,i,-1):\n",
    "        print(j,end='')\n",
    "    for j in range(i,n):\n",
    "        print(j+1,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 7\n",
      "       1\n",
      "      12\n",
      "     123\n",
      "    1234\n",
      "   12345\n",
      "  123456\n",
      " 1234567\n"
     ]
    }
   ],
   "source": [
    "# Half Pyramid Pattern of Numbers\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(n-i): \n",
    "        print(end=' ')    \n",
    "    for j in range(i+1): \n",
    "        print(j+1,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 7\n",
      "       11\n",
      "      1212\n",
      "     123123\n",
      "    12341234\n",
      "   1234512345\n",
      "  123456123456\n",
      " 12345671234567\n"
     ]
    }
   ],
   "source": [
    "# Pyramid of Numbers\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(n-i): \n",
    "        print(end=' ')    \n",
    "    for j in range(i+1): \n",
    "        print(j+1,end='')\n",
    "    for j in range(i+1):\n",
    "        print(j+1,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 7\n",
      "       11\n",
      "      1221\n",
      "     123321\n",
      "    12344321\n",
      "   1234554321\n",
      "  123456654321\n",
      " 12345677654321\n"
     ]
    }
   ],
   "source": [
    "# Pyramid of Numbers\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(n-i): \n",
    "        print(end=' ')    \n",
    "    for j in range(i+1): \n",
    "        print(j+1,end='')\n",
    "    for j in range(i+1,0,-1):\n",
    "        print(j,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 7\n",
      "       1\n",
      "      121\n",
      "     12321\n",
      "    1234321\n",
      "   123454321\n",
      "  12345654321\n",
      " 1234567654321\n"
     ]
    }
   ],
   "source": [
    "# Pyramid of Numbers\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(n-i): \n",
    "        print(end=' ')    \n",
    "    for j in range(i): \n",
    "        print(j+1,end='')\n",
    "    for j in range(i+1,0,-1):\n",
    "        print(j,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 9\n",
      "         1\n",
      "        121\n",
      "       12321\n",
      "      1234321\n",
      "     123454321\n",
      "    12345654321\n",
      "   1234567654321\n",
      "  123456787654321\n",
      " 12345678987654321\n",
      " 12345678987654321\n",
      "  123456787654321\n",
      "   1234567654321\n",
      "    12345654321\n",
      "     123454321\n",
      "      1234321\n",
      "       12321\n",
      "        121\n",
      "         1\n"
     ]
    }
   ],
   "source": [
    "# Pyramid of Numbers\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(n-i): \n",
    "        print(end=' ')    \n",
    "    for j in range(i): \n",
    "        print(j+1,end='')\n",
    "    for j in range(i+1,0,-1):\n",
    "        print(j,end='')\n",
    "    print()\n",
    "for i in range(n):\n",
    "    for j in range(i+1): \n",
    "        print(end=' ')\n",
    "    for j in range(1,n-i): \n",
    "        print(j,end='')    \n",
    "    for j in range(n-i,0,-1):\n",
    "        print(j,end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of rows :- 5\n",
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Number of rows :- \"))\n",
    "for i in range(n):\n",
    "    print('* '*(i+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 7\n",
      "       *\n",
      "      ***\n",
      "     *****\n",
      "    *******\n",
      "   *********\n",
      "  ***********\n",
      " *************\n"
     ]
    }
   ],
   "source": [
    "# Half Pyramid\n",
    "n = int(input('Enter size:- '))\n",
    "for i in range(n):\n",
    "    for j in range(n-i): \n",
    "        print(end=' ')    \n",
    "    for j in range(i): \n",
    "        print('*',end='')\n",
    "    for j in range(i+1,0,-1):\n",
    "        print('*',end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of rows:- 7\n",
      "       * \n",
      "      * * \n",
      "     * * * \n",
      "    * * * * \n",
      "   * * * * * \n",
      "  * * * * * * \n",
      " * * * * * * * \n"
     ]
    }
   ],
   "source": [
    "# Half Pyramid\n",
    "n = int(input(\"Number of rows:- \"))\n",
    "for i in range(n):\n",
    "    for j in range(n-i):\n",
    "        print(' ',end='')\n",
    "    for j in range(i+1):\n",
    "        print('* ',end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of rows:- 7\n",
      "      * \n",
      "     * * \n",
      "    * * * \n",
      "   * * * * \n",
      "  * * * * * \n",
      " * * * * * * \n",
      "* * * * * * * \n"
     ]
    }
   ],
   "source": [
    "# Half Pyramid\n",
    "n = int(input(\"Number of rows:- \"))\n",
    "for i in range(n):\n",
    "    print(' '*(n-i-1)+'* '*(i+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of rows:- 7\n",
      "* * * * * * * \n",
      " * * * * * * \n",
      "  * * * * * \n",
      "   * * * * \n",
      "    * * * \n",
      "     * * \n",
      "      * \n"
     ]
    }
   ],
   "source": [
    "# Inverted Pyramid\n",
    "n = int(input(\"Number of rows:- \"))\n",
    "for i in range(n):\n",
    "    for j in range(i):\n",
    "        print(' ',end='')\n",
    "    for j in range(n-i): \n",
    "        print('* ',end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of rows :- 7\n",
      "* * * * * * * \n",
      " * * * * * * \n",
      "  * * * * * \n",
      "   * * * * \n",
      "    * * * \n",
      "     * * \n",
      "      * \n"
     ]
    }
   ],
   "source": [
    "# Inverted Pyramid\n",
    "n = int(input(\"Number of rows :- \"))\n",
    "for i in range(n,0,-1):\n",
    "    print(' '*(n-i)+'* '*(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "         * \n",
      "        * * \n",
      "       * * * \n",
      "      * * * * \n",
      "     * * * * * \n",
      "    * * * * * * \n",
      "   * * * * * * * \n",
      "  * * * * * * * * \n",
      " * * * * * * * * * \n",
      "* * * * * * * * * * \n",
      " * * * * * * * * * \n",
      "  * * * * * * * * \n",
      "   * * * * * * * \n",
      "    * * * * * * \n",
      "     * * * * * \n",
      "      * * * * \n",
      "       * * * \n",
      "        * * \n",
      "         * \n",
      "          \n"
     ]
    }
   ],
   "source": [
    "# Pyramid\n",
    "n = int(input())\n",
    "for i in range(1,n+1):\n",
    "    for j in range(n-i):\n",
    "        print(' ',end='')\n",
    "    for j in range(i):\n",
    "        print('* ',end='')       \n",
    "    print()\n",
    "for i in range(n):\n",
    "    for j in range(i+1):\n",
    "        print(' ',end='')\n",
    "    for j in range(n-i-1): \n",
    "        print('* ',end='')\n",
    "    print() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of rows :- 10\n",
      "         * \n",
      "        * * \n",
      "       * * * \n",
      "      * * * * \n",
      "     * * * * * \n",
      "    * * * * * * \n",
      "   * * * * * * * \n",
      "  * * * * * * * * \n",
      " * * * * * * * * * \n",
      "* * * * * * * * * * \n",
      " * * * * * * * * * \n",
      "  * * * * * * * * \n",
      "   * * * * * * * \n",
      "    * * * * * * \n",
      "     * * * * * \n",
      "      * * * * \n",
      "       * * * \n",
      "        * * \n",
      "         * \n"
     ]
    }
   ],
   "source": [
    "# Pyramid\n",
    "n = int(input(\"Number of rows :- \"))\n",
    "for i in range(n):\n",
    "    print(' '*(n-i-1)+'* '*(i+1))\n",
    "for j in range(n-1,0,-1):\n",
    "    print(' '*(n-j)+'* '*(j))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "------------g------------\n",
      "----------g-f-g----------\n",
      "--------g-f-e-f-g--------\n",
      "------g-f-e-d-e-f-g------\n",
      "----g-f-e-d-c-d-e-f-g----\n",
      "--g-f-e-d-c-b-c-d-e-f-g--\n",
      "g-f-e-d-c-b-a-b-c-d-e-f-g\n",
      "--g-f-e-d-c-b-c-d-e-f-g--\n",
      "----g-f-e-d-c-d-e-f-g----\n",
      "------g-f-e-d-e-f-g------\n",
      "--------g-f-e-f-g--------\n",
      "----------g-f-g----------\n",
      "------------g------------\n"
     ]
    }
   ],
   "source": [
    "# Patterns\n",
    "n = int(input())\n",
    "import string\n",
    "from collections import defaultdict\n",
    "letters = string.ascii_lowercase\n",
    "index_dict = defaultdict(list)\n",
    "index_dict1 = defaultdict(list)\n",
    "mid = int((n*4-3)/2)\n",
    "count=0\n",
    "rows, cols = (n*2-1,n*4-3) \n",
    "dlist = [[-1 for i in range(cols)] for j in range(rows)]\n",
    "for i in range(1,n+1):\n",
    "    for j in range(mid,-mid-1,-2):\n",
    "        index_dict[letters[n-i]].append(abs(j))\n",
    "        \n",
    "    for j in range(mid,mid*2+1,2):  \n",
    "        index_dict1[letters[n-i]].append(j)\n",
    "        if j == mid*2:\n",
    "            for k in range(2,mid+2,2):\n",
    "                index_dict1[letters[n-i]].append(j-k)    \n",
    "    if i > 1:\n",
    "        count = count+2 \n",
    "        for m in range(1,count+1):\n",
    "            index_dict[letters[n-i]][n-i+m]='-' \n",
    "            index_dict1[letters[n-i]][n-i+m]='-'\n",
    "        for j in range(0,count):\n",
    "            index_dict[letters[n-i]].remove('-')\n",
    "            index_dict1[letters[n-i]].remove('-')\n",
    "            \n",
    "for i in range(0,n):\n",
    "    for j in range(i,n*2-1-i):\n",
    "        dlist[j][index_dict[letters[n-i-1]][j-i]]=letters[n-i-1]\n",
    "        dlist[j][index_dict1[letters[n-i-1]][j-i]]=letters[n-i-1]\n",
    "        \n",
    "for j in range(n*2-1):\n",
    "    print(''.join(list(str(i) if str(i).isalpha() else '-' for i in dlist[j]))) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter size:- 7\n",
      "       g\n",
      "      gfg\n",
      "     gfefg\n",
      "    gfedefg\n",
      "   gfedcdefg\n",
      "  gfedcbcdefg\n",
      " gfedcbabcdefg\n",
      " gfedcbabcdefg\n",
      "  gfedcbcdefg\n",
      "   gfedcdefg\n",
      "    gfedefg\n",
      "     gfefg\n",
      "      gfg\n",
      "       g\n"
     ]
    }
   ],
   "source": [
    "# Pyramid of alphabets\n",
    "n = int(input('Enter size:- '))\n",
    "import string\n",
    "letters = string.ascii_lowercase\n",
    "letters=letters[n-1::-1]\n",
    "for i in range(n):\n",
    "    for j in range(n-i): \n",
    "        print(end=' ')    \n",
    "    for j in range(i): \n",
    "        print(letters[j],end='') \n",
    "    for j in range(i+1,0,-1):\n",
    "        print(letters[j-1],end='')\n",
    "    print()\n",
    "for i in range(n):\n",
    "    for j in range(i+1): \n",
    "        print(end=' ')\n",
    "    for j in range(1,n-i):  \n",
    "        print(letters[j-1],end='')    \n",
    "    for j in range(n-i,0,-1):\n",
    "        print(letters[j-1],end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "66666666666\n",
      "65555555556\n",
      "65444444456\n",
      "65433333456\n",
      "65432223456\n",
      "65432123456\n",
      "65432223456\n",
      "65433333456\n",
      "65444444456\n",
      "65555555556\n",
      "66666666666\n"
     ]
    }
   ],
   "source": [
    "# Pattern\n",
    "n=int(input())\n",
    "ans=[[1]]\n",
    "for i in range(2, n+1):\n",
    "    t=[i]*((2*i)-3)\n",
    "    ans.insert(0, t)\n",
    "    ans.append(t.copy())\n",
    "    for a in ans:\n",
    "        a.insert(0,i)\n",
    "        a.append(i)\n",
    "ans_final=[]\n",
    "for a in ans:\n",
    "    ans_final.append(str(a).replace(' ','').replace(',','').replace(']','').replace('[',''))\n",
    "for a in ans_final:\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### End"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}