Posted on by Kalkicode
Code Pattern

Print N pattern

The task is to write a program that displays the N pattern of a given size. The N pattern is formed by printing asterisks (*) in a specific pattern that resembles the letter N.

Problem Statement

Given an integer size, the program should print the N pattern with the specified size. The pattern consists of asterisks (*) arranged in such a way that they form the shape of the letter N.

For example, for size = 5, the pattern looks like:

*   *
**  *
* * *
*  **
*   *

Similarly, for size = 7, the pattern looks like:

*     *
**    *
* *   *
*  *  *
*   * *
*    **
*     *

The task is to implement a C program that takes an integer size as input and prints the N pattern accordingly. The program should handle various test cases and display the output correctly.

Algorithm and Pseudocode

1. Start the program.

2. Define a function called "space" that takes an integer size as input.

3. Inside the "space" function, use a loop to print spaces based on the given size.

4. Define another function called "print_n" that takes an integer size as input.

5. Inside the "print_n" function, check if the size is less than or equal to 3. If so, return from the function as the pattern cannot be formed.

6. Print the size value as output to indicate the size of the pattern to be displayed.

7. Use a loop to iterate through each row of the pattern.

8. Inside the loop, print an asterisk (*) to start each row.

9. Check if the current row is not the first or last row. If so, print spaces and an asterisk (*) in the appropriate positions to form the N pattern.

10. If the current row is the first or last row, print spaces to maintain the pattern structure.

11. Print a new line after each row is printed.

12. Return to the loop and repeat steps 8-11 until all rows are printed.

13. Return to the main function.

14. Test the program by calling the "print_n" function with different test cases.

15. End the program.

The pseudocode for the program can be represented as:

function space(size):
	for i from 0 to size-1:
		print a space

function print_n(size):
	if size <= 3:
		return
	print "Size: " + size
	for i from 0 to size-1:
		print an asterisk (*)
		if i is not 0 and i is not size-1:
			call space(i-1)
			print an asterisk (*)
			call space((size-2)-i)
		else:
			call space(size-2)
		print an asterisk (*)
		print a new line

main:
	call print_n(5)
	call print_n(7)
	call print_n(4)
	call print_n(9)

Code Solution

// C Program
// Display N pattern 
#include <stdio.h>

//include space 
void space(int size)
{
	for (int i = 0; i < size; ++i)
	{
		printf(" ");
	}
}
void print_n(int size)
{
	if (size <= 3)
	{
		return;
	}
	printf("Size : %d\n\n", size);
	//Display Z pattern of given size
	for (int i = 0; i < size; i++)
	{
		printf("*");
		if (i != 0 && i != size - 1)
		{
			space(i - 1);
			printf("*");
			space((size - 2) - i);
		}
		else
		{
			space(size - 2);
		}
		printf("*");
		printf("\n");
	}
	printf("\n");
}
int main()
{
	//Test Case
	print_n(5);
	print_n(7);
	print_n(4);
	print_n(9);
	return 0;
}

Output

Size : 5

*   *
**  *
* * *
*  **
*   *

Size : 7

*     *
**    *
* *   *
*  *  *
*   * *
*    **
*     *

Size : 4

*  *
** *
* **
*  *

Size : 9

*       *
**      *
* *     *
*  *    *
*   *   *
*    *  *
*     * *
*      **
*       *
// C++ program
// Display N pattern 
#include<iostream>

using namespace std;
class MyPattern
{
	public:
		//include space 
		void space(int size)
		{
			for (int i = 0; i < size; ++i)
			{
				cout << " ";
			}
		}
	void print_n(int size)
	{
		if (size <= 3)
		{
			return;
		}
		cout << "Size : " << size << "\n\n";
		//Display Z pattern of given size
		for (int i = 0; i < size; i++)
		{
			cout << "*";
			if (i != 0 && i != size - 1)
			{
				this->space(i - 1);
				cout << "*";
				this->space((size - 2) - i);
			}
			else
			{
				this->space(size - 2);
			}
			cout << "*";
			cout << "\n";
		}
		cout << "\n";
	}
};
int main()
{
	MyPattern obj =  MyPattern();
	//Test Case
	obj.print_n(5);
	obj.print_n(7);
	obj.print_n(4);
	obj.print_n(9);
	return 0;
}

Output

Size : 5

*   *
**  *
* * *
*  **
*   *

Size : 7

*     *
**    *
* *   *
*  *  *
*   * *
*    **
*     *

Size : 4

*  *
** *
* **
*  *

Size : 9

*       *
**      *
* *     *
*  *    *
*   *   *
*    *  *
*     * *
*      **
*       *
// C# program
// Display N pattern 
using System;
class MyPattern
{
	//include space 
	public void space(int size)
	{
		for (int i = 0; i < size; i++)
		{
			Console.Write(" ");
		}
	}
	public void print_n(int size)
	{
		if (size <= 3)
		{
			return;
		}
		Console.Write("Size : " + size + "\n\n");
		//Display Z pattern of given size
		for (int i = 0; i < size; i++)
		{
			Console.Write("*");
			if (i != 0 && i != size - 1)
			{
				space(i - 1);
				Console.Write("*");
				space((size - 2) - i);
			}
			else
			{
				space(size - 2);
			}
			Console.Write("*");
			Console.Write("\n");
		}
		Console.Write("\n");
	}
	public static void Main(String[] args)
	{
		MyPattern obj = new MyPattern();
		//Test Case
		obj.print_n(5);
		obj.print_n(7);
		obj.print_n(4);
		obj.print_n(9);
	}
}

Output

Size : 5

*   *
**  *
* * *
*  **
*   *

Size : 7

*     *
**    *
* *   *
*  *  *
*   * *
*    **
*     *

Size : 4

*  *
** *
* **
*  *

Size : 9

*       *
**      *
* *     *
*  *    *
*   *   *
*    *  *
*     * *
*      **
*       *
// Java program
// Display N pattern 
class MyPattern
{
	//include space 
	public void space(int size)
	{
		for (int i = 0; i < size; ++i)
		{
			System.out.print(" ");
		}
	}
	public void print_n(int size)
	{
		if (size <= 3)
		{
			return;
		}
		System.out.print("Size : " + size + "\n\n");
		//Display Z pattern of given size
		for (int i = 0; i < size; i++)
		{
			System.out.print("*");
			if (i != 0 && i != size - 1)
			{
				space(i - 1);
				System.out.print("*");
				space((size - 2) - i);
			}
			else
			{
				space(size - 2);
			}
			System.out.print("*");
			System.out.print("\n");
		}
		System.out.print("\n");
	}
	public static void main(String[] args)
	{
		MyPattern obj = new MyPattern();
		//Test Case
		obj.print_n(5);
		obj.print_n(7);
		obj.print_n(4);
		obj.print_n(9);
	}
}

Output

Size : 5

*   *
**  *
* * *
*  **
*   *

Size : 7

*     *
**    *
* *   *
*  *  *
*   * *
*    **
*     *

Size : 4

*  *
** *
* **
*  *

Size : 9

*       *
**      *
* *     *
*  *    *
*   *   *
*    *  *
*     * *
*      **
*       *
<?php
// Php program
// Display N pattern 
class MyPattern
{
	//include space 
	public 	function space($size)
	{
		for ($i = 0; $i < $size; ++$i)
		{
			echo(" ");
		}
	}
	public 	function print_n($size)
	{
		if ($size <= 3)
		{
			return;
		}
		echo("Size : ". $size ."\n\n");
		//Display Z pattern of given size
		for ($i = 0; $i < $size; $i++)
		{
			echo("*");
			if ($i != 0 && $i != $size - 1)
			{
				$this->space($i - 1);
				echo("*");
				$this->space(($size - 2) - $i);
			}
			else
			{
				$this->space($size - 2);
			}
			echo("*");
			echo("\n");
		}
		echo("\n");
	}
}

function main()
{
	$obj = new MyPattern();
	//Test Case
	$obj->print_n(5);
	$obj->print_n(7);
	$obj->print_n(4);
	$obj->print_n(9);
}
main();

Output

Size : 5

*   *
**  *
* * *
*  **
*   *

Size : 7

*     *
**    *
* *   *
*  *  *
*   * *
*    **
*     *

Size : 4

*  *
** *
* **
*  *

Size : 9

*       *
**      *
* *     *
*  *    *
*   *   *
*    *  *
*     * *
*      **
*       *
// Node Js program
// Display N pattern 
class MyPattern
{
	//include space 
	space(size)
	{
		for (var i = 0; i < size; ++i)
		{
			process.stdout.write(" ");
		}
	}
	print_n(size)
	{
		if (size <= 3)
		{
			return;
		}
		process.stdout.write("Size : " + size + "\n\n");
		//Display Z pattern of given size
		for (var i = 0; i < size; i++)
		{
			process.stdout.write("*");
			if (i != 0 && i != size - 1)
			{
				this.space(i - 1);
				process.stdout.write("*");
				this.space((size - 2) - i);
			}
			else
			{
				this.space(size - 2);
			}
			process.stdout.write("*");
			process.stdout.write("\n");
		}
		process.stdout.write("\n");
	}
}

function main(args)
{
	var obj = new MyPattern();
	//Test Case
	obj.print_n(5);
	obj.print_n(7);
	obj.print_n(4);
	obj.print_n(9);
}
main();

Output

Size : 5

*   *
**  *
* * *
*  **
*   *

Size : 7

*     *
**    *
* *   *
*  *  *
*   * *
*    **
*     *

Size : 4

*  *
** *
* **
*  *

Size : 9

*       *
**      *
* *     *
*  *    *
*   *   *
*    *  *
*     * *
*      **
*       *
#  Python 3 program
#  Display N pattern 
class MyPattern :
	# include space 
	def space(self, size) :
		i = 0
		while (i < size) :
			print(" ", end = "")
			i += 1
		
	
	def print_n(self, size) :
		if (size <= 3) :
			return
		
		print("Size : ", size ,"\n\n", end = "")
		# Display Z pattern of given size
		i = 0
		while (i < size) :
			print("*", end = "")
			if (i != 0 and i != size - 1) :
				self.space(i - 1)
				print("*", end = "")
				self.space((size - 2) - i)
			else :
				self.space(size - 2)
			
			print("*", end = "")
			print("\n", end = "")
			i += 1
		
		print("\n", end = "")
	

def main() :
	obj = MyPattern()
	# Test Case
	obj.print_n(5)
	obj.print_n(7)
	obj.print_n(4)
	obj.print_n(9)


if __name__ == "__main__": main()

Output

Size :  5

*   *
**  *
* * *
*  **
*   *

Size :  7

*     *
**    *
* *   *
*  *  *
*   * *
*    **
*     *

Size :  4

*  *
** *
* **
*  *

Size :  9

*       *
**      *
* *     *
*  *    *
*   *   *
*    *  *
*     * *
*      **
*       *
#  Ruby program
#  Display N pattern 
class MyPattern

	# include space 
	def space(size)
	
		i = 0
		while (i < size)
		
			print(" ")
			i += 1
		end
	end
	def print_n(size)
	
		if (size <= 3)
		
			return
		end
		print("Size  : ", size ,"\n\n")
		# Display Z pattern of given size
		i = 0
		while (i < size)
		
			print("*")
			if (i != 0 && i != size - 1)
			
				self.space(i - 1)
				print("*")
				self.space((size - 2) - i)
			else
			
				self.space(size - 2)
			end
			print("*")
			print("\n")
			i += 1
		end
		print("\n")
	end
end
def main()

	obj = MyPattern.new()
	# Test Case
	obj.print_n(5)
	obj.print_n(7)
	obj.print_n(4)
	obj.print_n(9)
end
main()

Output

Size  : 5

*   *
**  *
* * *
*  **
*   *

Size  : 7

*     *
**    *
* *   *
*  *  *
*   * *
*    **
*     *

Size  : 4

*  *
** *
* **
*  *

Size  : 9

*       *
**      *
* *     *
*  *    *
*   *   *
*    *  *
*     * *
*      **
*       *

// Scala program
// Display N pattern 
class MyPattern
{
	//include space 
	def space(size: Int): Unit = {
		var i: Int = 0;
		while (i < size)
		{
			print(" ");
			i += 1;
		}
	}
	def print_n(size: Int): Unit = {
		if (size <= 3)
		{
			return;
		}
		print("Size : " + size + "\n\n");
		//Display Z pattern of given size
		var i: Int = 0;
		while (i < size)
		{
			print("*");
			if (i != 0 && i != size - 1)
			{
				space(i - 1);
				print("*");
				space((size - 2) - i);
			}
			else
			{
				space(size - 2);
			}
			print("*");
			print("\n");
			i += 1;
		}
		print("\n");
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var obj: MyPattern = new MyPattern();
		//Test Case
		obj.print_n(5);
		obj.print_n(7);
		obj.print_n(4);
		obj.print_n(9);
	}
}

Output

Size : 5

*   *
**  *
* * *
*  **
*   *

Size : 7

*     *
**    *
* *   *
*  *  *
*   * *
*    **
*     *

Size : 4

*  *
** *
* **
*  *

Size : 9

*       *
**      *
* *     *
*  *    *
*   *   *
*    *  *
*     * *
*      **
*       *
// Swift program
// Display N pattern 
class MyPattern
{
	//include space 
	func space(_ size: Int)
	{
		var i: Int = 0;
		while (i < size)
		{
			print(" ", terminator: "");
			i += 1;
		}
	}
	func print_n(_ size: Int)
	{
		if (size <= 3)
		{
			return;
		}
		print("Size : ", size ,"\n\n", terminator: "");
		//Display Z pattern of given size
		var i: Int = 0;
		while (i < size)
		{
			print("*", terminator: "");
			if (i != 0 && i != size - 1)
			{
				self.space(i - 1);
				print("*", terminator: "");
				self.space((size - 2) - i);
			}
			else
			{
				self.space(size - 2);
			}
			print("*", terminator: "");
			print("\n", terminator: "");
			i += 1;
		}
		print("\n", terminator: "");
	}
}
func main()
{
	let obj: MyPattern = MyPattern();
	//Test Case
	obj.print_n(5);
	obj.print_n(7);
	obj.print_n(4);
	obj.print_n(9);
}
main();

Output

Size :  5

*   *
**  *
* * *
*  **
*   *

Size :  7

*     *
**    *
* *   *
*  *  *
*   * *
*    **
*     *

Size :  4

*  *
** *
* **
*  *

Size :  9

*       *
**      *
* *     *
*  *    *
*   *   *
*    *  *
*     * *
*      **
*       *

Resultant Output Explanation

The program generates the following output for the given test cases:

Size : 5

*   *
**  *
* * *
*  **
*   *

Size : 7

*     *
**    *
* *   *
*  *  *
*   * *
*    **
*     *

Size : 4

*  *
** *
* **
*  *

Size : 9

*       *
**      *
* *     *
*  *    *
*   *   *
*    *  *
*     * *
*      **
*       *

The output shows the N pattern for each given size. Each asterisk (*) represents a character in the pattern, while spaces are used to align the asterisks in the desired shape. The pattern follows the logic explained in the algorithm section.

The time complexity of the code is O(n^2) because there are two nested loops. The outer loop iterates through each row, and the inner loop prints the spaces and asterisks in each row. The space function has a time complexity of O(n) as it simply prints spaces based on the given size.

Overall, the program successfully generates the N pattern for a given size and handles different test cases accordingly.

Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment