Open In App

# Program to print ‘N’ alphabet using the number pattern from 1 to n

Given an integer N, the task is to print the Alphabet N Pattern as given below:

```1           1
2 2         2
3   3       3
*    *      *
*      *    *
*        *  *
N           N```

Examples:

```Input: N = 6
Output:
1           1
2  2        2
3    3      3
4      4    4
5        5  5
6           6

Input: N = 5
Output:
1         1
2  2      2
3    3    3
4      4  4
5         5```

Approach: Except the first and the last row, every other row will follow the following:

• Print the first value as index + 1 where index is the index of the row.
• Then print blank spaces 2 * index times.
• Again print the value index + 1 as the diagonal element for the current row.
• Then print the rest of the 2 * (N – index – 1) blank spaces followed by the ending element which is again index + 1.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to print the desired Alphabet N Pattern``void` `Alphabet_N_Pattern(``int` `N)``{` `    ``int` `index, side_index, size;` `    ``// Declaring the values of Right, Left and Diagonal values``    ``int` `Right = 1, Left = 1, Diagonal = 2;` `    ``// Main Loop for the rows``    ``for` `(index = 0; index < N; index++) {` `        ``// For the left Values``        ``cout << Left++;` `        ``// Spaces for the diagonals``        ``for` `(side_index = 0; side_index < 2 * (index); side_index++)``            ``cout << ``" "``;` `        ``// Condition for the diagonals``        ``if` `(index != 0 && index != N - 1)``            ``cout << Diagonal++;``        ``else``            ``cout << ``" "``;` `        ``// Spaces for the Right Values``        ``for` `(side_index = 0; side_index < 2 * (N - index - 1); side_index++)``            ``cout << ``" "``;` `        ``// For the right values``        ``cout << Right++;` `        ``cout << endl;``    ``}``}` `// Driver Code``int` `main(``int` `argc, ``char``** argv)``{``    ``// Size of the Pattern``    ``int` `Size = 6;` `    ``// Calling the function to print the desired Pattern``    ``Alphabet_N_Pattern(Size);``}`

## C

 `// C implementation of the approach``#include ` `// Function to print the desired Alphabet N Pattern``void` `Alphabet_N_Pattern(``int` `N)``{` `    ``int` `index, side_index, size;` `    ``// Declaring the values of Right, Left and Diagonal values``    ``int` `Right = 1, Left = 1, Diagonal = 2;` `    ``// Main Loop for the rows``    ``for` `(index = 0; index < N; index++) {` `        ``// For the left Values``        ``printf``(``"%d"``, Left++);` `        ``// Spaces for the diagonals``        ``for` `(side_index = 0; side_index < 2 * (index); side_index++)``            ``printf``(``" "``);` `        ``// Condition for the diagonals``        ``if` `(index != 0 && index != N - 1)``            ``printf``(``"%d"``, Diagonal++);``        ``else``            ``printf``(``" "``);` `        ``// Spaces for the Right Values``        ``for` `(side_index = 0; side_index < 2 * (N - index - 1); side_index++)``            ``printf``(``" "``);` `        ``// For the right values``        ``printf``(``"%d"``, Right++);` `        ``printf``(``"\n"``);``    ``}``}` `// Driver Code``int` `main(``int` `argc, ``char``** argv)``{``    ``// Size of the Pattern``    ``int` `Size = 6;` `    ``// Calling the function to print the desired Pattern``    ``Alphabet_N_Pattern(Size);``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;`  `class` `solution``{` `// Function to print the desired Alphabet N Pattern``static` `void` `Alphabet_N_Pattern(``int` `N)``{` `    ``int` `index, side_index, size;` `    ``// Declaring the values of Right, Left and Diagonal values``    ``int` `Right = ``1``, Left = ``1``, Diagonal = ``2``;` `    ``// Main Loop for the rows``    ``for` `(index = ``0``; index < N; index++) {` `        ``// For the left Values``        ``System.out.print(Left++);` `        ``// Spaces for the diagonals``        ``for` `(side_index = ``0``; side_index < ``2` `* (index); side_index++)``            ``System.out.print(``" "``);` `        ``// Condition for the diagonals``        ``if` `(index != ``0` `&& index != N - ``1``)``            ``System.out.print(Diagonal++);``        ``else``            ``System.out.print(``" "``);` `        ``// Spaces for the Right Values``        ``for` `(side_index = ``0``; side_index < ``2` `* (N - index - ``1``); side_index++)``            ``System.out.print(``" "``);` `        ``// For the right values``        ``System.out.print(Right++);` `        ``System.out.println();``    ``}``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``// Size of the Pattern``    ``int` `Size = ``6``;` `    ``// Calling the function to print the desired Pattern``    ``Alphabet_N_Pattern(Size);``}` `}` `// This code is contributed by``// Surendra_Gagwar`

## Python3

 `# Python 3 implementation of the approach` `# Function to print the desired``# Alphabet N Pattern``def` `Alphabet_N_Pattern(N):``    ` `    ``# Declaring the values of Right, Left``    ``# and Diagonal values``    ``Right ``=` `1``    ``Left ``=` `1``    ``Diagonal ``=` `2` `    ``# Main Loop for the rows``    ``for` `index ``in` `range``(N):``        ` `        ``# For the left Values``        ``print``(Left, end ``=` `"")``        ``Left ``+``=` `1` `        ``# Spaces for the diagonals``        ``for` `side_index ``in` `range``(``0``, ``2` `*` `(index), ``1``):``            ``print``(``" "``, end ``=` `"")` `        ``# Condition for the diagonals``        ``if` `(index !``=` `0` `and` `index !``=` `N ``-` `1``):``            ``print``(Diagonal, end ``=` `"")``            ``Diagonal ``+``=` `1``        ``else``:``            ``print``(``" "``, end ``=` `"")` `        ``# Spaces for the Right Values``        ``for` `side_index ``in` `range``(``0``, ``2` `*` `(N ``-` `index ``-` `1``), ``1``):``            ``print``(``" "``, end ``=` `"")` `        ``# For the right values``        ``print``(Right, end ``=` `"")``        ``Right ``+``=` `1``        ` `        ``print``(``"\n"``, end ``=` `"")``    ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Size of the Pattern``    ``Size ``=` `6` `    ``# Calling the function to print``    ``# the desired Pattern``    ``Alphabet_N_Pattern(Size)` `# This code is contributed by``# Sanjit_Prasad`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``    ` `// Function to print the desired Alphabet N Pattern``public` `static` `void` `Alphabet_N_Pattern(``int` `N)``{` `    ``int` `index, side_index;``    ` `    ``// Declaring the values of Right,``    ``// Left and Diagonal values``    ``int` `Right = 1, Left = 1, Diagonal = 2;``    ` `    ``// Main Loop for the rows``    ``for` `(index = 0; index < N; index++)``    ``{` `        ``// For the left Values``        ``Console.Write(Left++);` `        ``// Spaces for the diagonals``        ``for` `(side_index = 0;``             ``side_index < 2 * (index); side_index++)``            ``Console.Write(``" "``);` `        ``// Condition for the diagonals``        ``if` `(index != 0 && index != N - 1)``            ``Console.Write(Diagonal++);``        ``else``            ``Console.Write(``" "``);``        ` `        ``// Spaces for the Right Values``        ``for` `(side_index = 0;``             ``side_index < 2 * (N - index - 1);``             ``side_index++)``            ``Console.Write(``" "``);` `        ``// For the right values``        ``Console.Write(Right++);` `        ``Console.Write(``"\n"``);``    ``}``}` `// Driver Code``static` `void` `Main()``{``    ``// Size of the Pattern``    ``int` `Size = 6;` `    ``// Calling the function to print``    ``// the desired Pattern``    ``Alphabet_N_Pattern(Size);``}``}` `// This code is contributed by DrRoot_`

## PHP

 ``

## Javascript

 ``

Output:

```1           1
2  2        2
3    3      3
4      4    4
5        5  5
6           6```

Time Complexity: O(n2)

Auxiliary Space: O(1)