# Draw Swastika Pattern

The swastika pattern is a symbol that has been used for thousands of years in various cultures around the world. It is a geometric pattern that consists of four arms that are bent at right angles and point in a clockwise or counterclockwise direction.

In Hinduism, the swastika is considered a sacred symbol and represents good luck, prosperity, and well-being. It is often used in religious ceremonies, and can be seen in many Hindu temples and homes.

In Buddhism, the swastika is known as the "Wheel of Law" and is used to represent the Buddha's teachings. It is often depicted on Buddhist temples and is a symbol of peace, love, and harmony.

In this article, we will discuss how to draw a swastika pattern using Java programming language. The swastika is a symbol that holds religious and cultural significance in various traditions. It consists of an equilateral cross with arms bent at right angles. We will create a Java program that generates the swastika pattern based on a given size.

## Problem Statement

The problem is to create a program that takes a size as input and displays a swastika pattern of that size. The size determines the dimensions of the swastika pattern, and it should be an odd number greater than 3.

For example, if the size is 5, the program should generate the following pattern:

``` *   * * *
*   *
* * * * *
*   *
* * *   *
```

## Algorithm

1. Start the program.

2. Define a class named "MyPattern" that contains the "swastikaPattern" method.

3. In the "swastikaPattern" method:

a. Check if the size is less than or equal to 3 or if it is an even number. If true, return as it is an invalid size for the pattern.

b. Print the size of the pattern.

c. Use nested loops to iterate over each position in the pattern.

d. Inside the loops, check the conditions to determine whether to print an asterisk (*) or a space ( ).

e. Print the asterisk (*) if it falls within the boundary cases that form the swastika shape, otherwise print a space ( ).

f. After each row is printed, include a new line character to move to the next row.

4. Define the "main" method in the "MyPattern" class.

5. Create an instance of the "MyPattern" class.

6. Test the "swastikaPattern" method by calling it with different sizes (e.g., 5, 7, 9, 11).

7. End the program.

## Pseudocode

``````
class MyPattern
method swastikaPattern(size)
if (size <= 3 OR size is even)
return
print("Size: " + size)
for i = 0 to size
for j = 0 to size
if ((i < size / 2 AND j == 0) OR
(j == size / 2) OR
(i == size / 2) OR
(i == 0 AND j > (size / 2)) OR
(i == size - 1 AND j < size / 2) OR
(i > size / 2 AND j == size - 1))
print(" *")
else
print("  ")
print("\n")
end method

method main(args)
end method
end class```
```

## Code Solution

``````/*
Java Program
Display Wave Patterns
*/
public class MyPattern
{
// Displaying of swastika Pattern in given size
public void swastikaPattern(int size)
{
if (size <= 3 || size % 2 == 0)
{
// When get a invalid size of pattern
return;
}
System.out.print("\n Size : " + size + "\n\n");
for (int i = 0; i < size; ++i)
{
for (int j = 0; j < size; ++j)
{
// Simple test the boundary cases
if ((i < size / 2 && j == 0) ||
(j == size / 2) || (i == size / 2) ||
(i == 0 && j > (size / 2)) ||
(i == size - 1 && j < size / 2) ||
(i > size / 2 && j == size - 1))
{
System.out.print(" *");
}
else
{
System.out.print("  ");
}
}
//include new line
System.out.print("\n");
}
}
public static void main(String[] args)
{
// Test
}
}``````

#### Output

`````` Size : 5

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

Size : 7

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

Size : 9

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

Size : 11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *``````
``````// Include header file
#include <iostream>
using namespace std;
/*
C++ Program
Display Wave Patterns
*/
class MyPattern
{
public:
// Displaying of swastika Pattern in given size
void swastikaPattern(int size)
{
if (size <= 3 || size % 2 == 0)
{
// When get a invalid size of pattern
return;
}
cout << "\n Size : " << size << "\n\n";
for (int i = 0; i < size; ++i)
{
for (int j = 0; j < size; ++j)
{
// Simple test the boundary cases
if ((i < size / 2 && j == 0) ||
(j == size / 2) ||
(i == size / 2) ||
(i == 0 && j > (size / 2)) ||
(i == size - 1 && j < size / 2) ||
(i > size / 2 && j == size - 1))
{
cout << " *";
}
else
{
cout << "  ";
}
}
//include new line
cout << "\n";
}
}
};
int main()
{
// Test
return 0;
}``````

#### Output

`````` Size : 5

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

Size : 7

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

Size : 9

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

Size : 11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *``````
``````// C Program
// Draw Swastika Pattern
#include <stdio.h>
#include <stdlib.h>

// Displaying of swastika Pattern in given size
void swastika_pattern(int size)
{
if (size <= 3 || size % 2 == 0)
{
// When get a invalid size of pattern
return;
}
printf("\n Size : %d\n\n", size);
for (int i = 0; i < size; ++i)
{
for (int j = 0; j < size; ++j)
{
// Simple test the boundary cases
if ((i < size / 2 && j == 0) ||
(j == size / 2) || (i == size / 2) ||
(i == 0 && j > (size / 2)) ||
(i == size - 1 && j < size / 2) ||
(i > size / 2 && j == size - 1))
{
printf(" *");
}
else
{
printf("  ");
}
}
//include new line
printf("\n");
}
}
int main()
{
//Test Cases
swastika_pattern(5);
swastika_pattern(7);
swastika_pattern(9);
swastika_pattern(11);
return 0;
}``````

#### Output

`````` Size : 5

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

Size : 7

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

Size : 9

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

Size : 11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *``````
``````package main
import "fmt"
/*
Go Program
Display Wave Patterns
*/

// Displaying of swastika Pattern in given size
func swastikaPattern(size int) {
if size <= 3 || size % 2 == 0 {
// When get a invalid size of pattern
return
}
fmt.Print("\n Size : ", size, "\n\n")
for i := 0 ; i < size ; i++ {
for j := 0 ; j < size ; j++ {
// Simple test the boundary cases
if (i < size / 2 && j == 0) ||
(j == size / 2) ||
(i == size / 2) ||
(i == 0 && j > (size / 2)) ||
(i == size - 1 && j < size / 2) ||
(i > size / 2 && j == size - 1) {
fmt.Print(" *")
} else {
fmt.Print("  ")
}
}
//include new line
fmt.Print("\n")
}
}
func main() {

// Test
swastikaPattern(5)
swastikaPattern(7)
swastikaPattern(9)
swastikaPattern(11)
}``````

#### Output

`````` Size : 5

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

Size : 7

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

Size : 9

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

Size : 11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *``````
``````// Include namespace system
using System;
/*
Csharp Program
Display Wave Patterns
*/
public class MyPattern
{
// Displaying of swastika Pattern in given size
public void swastikaPattern(int size)
{
if (size <= 3 || size % 2 == 0)
{
// When get a invalid size of pattern
return;
}
Console.Write("\n Size : " + size + "\n\n");
for (int i = 0; i < size; ++i)
{
for (int j = 0; j < size; ++j)
{
// Simple test the boundary cases
if ((i < size / 2 && j == 0) ||
(j == size / 2) || (i == size / 2) ||
(i == 0 && j > (size / 2)) ||
(i == size - 1 && j < size / 2) ||
(i > size / 2 && j == size - 1))
{
Console.Write(" *");
}
else
{
Console.Write("  ");
}
}
//include new line
Console.Write("\n");
}
}
public static void Main(String[] args)
{
// Test
}
}``````

#### Output

`````` Size : 5

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

Size : 7

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

Size : 9

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

Size : 11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *``````
``````<?php
/*
Php Program
Display Wave Patterns
*/
class MyPattern
{
// Displaying of swastika Pattern in given size
public  function swastikaPattern(\$size)
{
if (\$size <= 3 || \$size % 2 == 0)
{
// When get a invalid size of pattern
return;
}
print_r("\n Size : ".strval(\$size).
"\n\n");
for (\$i = 0; \$i < \$size; ++\$i)
{
for (\$j = 0; \$j < \$size; ++\$j)
{
// Simple test the boundary cases
if ((\$i < (int)(\$size / 2) && \$j == 0) ||
(\$j == (int)(\$size / 2)) ||
(\$i == (int)(\$size / 2)) ||
(\$i == 0 && \$j > ((int)(\$size / 2))) ||
(\$i == \$size - 1 && \$j < (int)(\$size / 2)) ||
(\$i > (int)(\$size / 2) && \$j == \$size - 1))
{
print_r(" *");
}
else
{
print_r("  ");
}
}
//include new line
print_r("\n");
}
}
public static
function main(\$args)
{
// Test
}
}
MyPattern::main(array());``````

#### Output

`````` Size : 5

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

Size : 7

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

Size : 9

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

Size : 11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *``````
``````/*
Node JS Program
Display Wave Patterns
*/
class MyPattern
{
// Displaying of swastika Pattern in given size
swastikaPattern(size)
{
if (size <= 3 || size % 2 == 0)
{
// When get a invalid size of pattern
return;
}
process.stdout.write("\n Size : " + size + "\n\n");
for (var i = 0; i < size; ++i)
{
for (var j = 0; j < size; ++j)
{
// Simple test the boundary cases
if ((i < parseInt(size / 2) && j == 0) ||
(j == parseInt(size / 2)) ||
(i == parseInt(size / 2)) ||
(i == 0 && j > (parseInt(size / 2))) ||
(i == size - 1 && j < parseInt(size / 2)) ||
(i > parseInt(size / 2) && j == size - 1))
{
process.stdout.write(" *");
}
else
{
process.stdout.write("  ");
}
}
//include new line
process.stdout.write("\n");
}
}
}

function main()
{
// Test
}
main();``````

#### Output

`````` Size : 5

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

Size : 7

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

Size : 9

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

Size : 11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *``````
``````#  Python 3 Program
#  Display Wave Patterns
class MyPattern :
#  Displaying of swastika Pattern in given size
def swastikaPattern(self, size) :
if (size <= 3 or size % 2 == 0) :
#  When get a invalid size of pattern
return

print("\n Size : ", size ,"\n")
i = 0
while (i < size) :
j = 0
while (j < size) :
#  Simple test the boundary cases
if ((i < int(size / 2) and j == 0) or
(j == int(size / 2)) or
(i == int(size / 2)) or
(i == 0 and j > (int(size / 2))) or
(i == size - 1 and j < int(size / 2)) or
(i > int(size / 2) and j == size - 1)) :
print(" *", end = "")
else :
print("  ", end = "")

j += 1

# include new line
print(end = "\n")
i += 1

def main() :
#  Test

if __name__ == "__main__": main()``````

#### Output

`````` Size :  5

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

Size :  7

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

Size :  9

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

Size :  11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *``````
``````#  Ruby Program
#  Display Wave Patterns
class MyPattern
#  Displaying of swastika Pattern in given size
def swastikaPattern(size)
if (size <= 3 || size % 2 == 0)
#  When get a invalid size of pattern
return
end

print("\n Size : ", size ,"\n\n")
i = 0
while (i < size)
j = 0
while (j < size)
#  Simple test the boundary cases
if ((i < size / 2 && j == 0) ||
(j == size / 2) || (i == size / 2) ||
(i == 0 && j > (size / 2)) ||
(i == size - 1 && j < size / 2) ||
(i > size / 2 && j == size - 1))
print(" *")
else

print("  ")
end

j += 1
end

# include new line
print("\n")
i += 1
end

end

end

def main()
#  Test
end

main()``````

#### Output

`````` Size : 5

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

Size : 7

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

Size : 9

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

Size : 11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *
``````
``````/*
Scala Program
Display Wave Patterns
*/
class MyPattern()
{
// Displaying of swastika Pattern in given size
def swastikaPattern(size: Int): Unit = {
if (size <= 3 || size % 2 == 0)
{
// When get a invalid size of pattern
return;
}
print("\n Size : " + size + "\n\n");
var i: Int = 0;
while (i < size)
{
var j: Int = 0;
while (j < size)
{
// Simple test the boundary cases
if ((i < size / 2 && j == 0) ||
(j == size / 2) || (i == size / 2) ||
(i == 0 && j > (size / 2)) ||
(i == size - 1 && j < size / 2) ||
(i > size / 2 && j == size - 1))
{
print(" *");
}
else
{
print("  ");
}
j += 1;
}
//include new line
print("\n");
i += 1;
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: MyPattern = new MyPattern();
// Test
}
}``````

#### Output

`````` Size : 5

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

Size : 7

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

Size : 9

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

Size : 11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *``````
``````/*
Swift 4 Program
Display Wave Patterns
*/
class MyPattern
{
// Displaying of swastika Pattern in given size
func swastikaPattern(_ size: Int)
{
if (size <= 3 || size % 2 == 0)
{
// When get a invalid size of pattern
return;
}
print("\n Size : ", size ,"\n");
var i: Int = 0;
while (i < size)
{
var j: Int = 0;
while (j < size)
{
// Simple test the boundary cases
if ((i < size / 2 && j == 0) ||
(j == size / 2) ||
(i == size / 2) ||
(i == 0 && j > (size / 2)) ||
(i == size - 1 && j < size / 2) ||
(i > size / 2 && j == size - 1))
{
print(" *", terminator: "");
}
else
{
print("  ", terminator: "");
}
j += 1;
}
//include new line
print(terminator: "\n");
i += 1;
}
}
}
func main()
{
// Test
}
main();``````

#### Output

`````` Size :  5

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

Size :  7

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

Size :  9

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

Size :  11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *``````
``````/*
Kotlin Program
Display Wave Patterns
*/
class MyPattern
{
// Displaying of swastika Pattern in given size
fun swastikaPattern(size: Int): Unit
{
if (size <= 3 || size % 2 == 0)
{
// When get a invalid size of pattern
return;
}
print("\n Size : " + size + "\n\n");
var i: Int = 0;
while (i < size)
{
var j: Int = 0;
while (j < size)
{
// Simple test the boundary cases
if ((i < size / 2 && j == 0) ||
(j == size / 2) ||
(i == size / 2) ||
(i == 0 && j > (size / 2)) ||
(i == size - 1 && j < size / 2) ||
(i > size / 2 && j == size - 1))
{
print(" *");
}
else
{
print("  ");
}
j += 1;
}
//include new line
print("\n");
i += 1;
}
}
}
fun main(args: Array < String > ): Unit
{
// Test
}``````

#### Output

`````` Size : 5

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

Size : 7

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

Size : 9

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

Size : 11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *``````

## Output Explanation

The program generates the swastika pattern for different sizes. Here is the explanation for each output:

For size 5:

``` Size: 5

*   * * *
*   *
* * * * *
*   *
* * *   *
```

For size 7:

``` Size: 7

*     * * * *
*     *
*     *
* * * * * * *
*     *
*     *
* * * *     *
```

For size 9:

``` Size: 9

*       * * * * *
*       *
*       *
*       *
* * * * * * * * *
*       *
*       *
*       *
* * * * *       *
```

For size 11:

``` Size: 11

*         * * * * * *
*         *
*         *
*         *
*         *
* * * * * * * * * * *
*         *
*         *
*         *
*         *
* * * * * *         *
```

## Time Complexity

The time complexity of the program is O(n^2), where n represents the size of the pattern. The program uses nested loops to iterate over each position in the pattern, resulting in a quadratic time complexity.

By following the provided algorithm and pseudocode, you can draw the swastika pattern of various sizes using Java programming language.

## 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.