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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <iostream>
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);
}

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

// C implementation of the approach
#include <stdio.h>
  
// 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);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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_

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of the approach 
  
// Function to print the desired
// Alphabet N Pattern 
function Alphabet_N_Pattern($N
    $index;
    $side_index;
    $size
  
    // Declaring the values of Right, 
    // Left and Diagonal values 
    $Right = 1;
    $Left = 1;
    $Diagonal = 2; 
  
    // Main Loop for the rows 
    for ($index = 0; $index < $N; $index++) 
    
  
        // For the left Values 
        echo $Left++; 
  
        // Spaces for the diagonals 
        for ($side_index = 0; 
             $side_index < 2 * ($index);
             $side_index++) 
            echo " "
  
        // Condition for the diagonals 
        if ($index != 0 && $index != $N - 1) 
            echo $Diagonal++; 
        else
            echo " "
  
        // Spaces for the Right Values 
        for ($side_index = 0;
             $side_index < 2 * ($N - $index - 1); 
             $side_index++) 
            echo " "
  
        // For the right values 
        echo $Right++; 
  
        echo "\n"
    
  
// Driver Code 
  
// Size of the Pattern 
$Size = 6; 
  
// Calling the function to
// print the desired Pattern 
Alphabet_N_Pattern($Size); 
  
// This code is contributed by ajit
?>

chevron_right


Output:

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


My Personal Notes arrow_drop_up


If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.