# Star pattern programs [Tricks] in java

In this article, you will see how to print Star patterns in java. Here you will learn the simple tricks to develop the logic for Star pattern printing. These tricks will not only help you to understand the Star pattern programs but also help you to understand Alphabet/Character patterns and Number patterns.

Pattern printing programs help you to enhance your logical skills, coding, and looping concept. These programs are frequently asked by the interviewer to check the logical skills of the programmer.

## Tricks to develop pattern programs logic

Here you are going to learn 8 simple tricks to develop almost all types of pattern programs. All the tricks will be in three steps, first two steps are simple but the third step is a little tricky. The third step is very important for developing the logic.

Let’s see all the 8 tricks one by one:

### Trick-1

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

Let’s develop the logic for the above pattern:

Let me explain the above steps with simple points:

Step-1:

• Given pattern

Step-2:

• The given pattern can be converted in to the box format like the above.
• The box format is repersented in Rows(1,2,3,4,5) and Columns(1,2,3,4,5).

Step-3:

• Let’s assume variable n(required number of rows), eg. n=5.
• In the above image, the blue color area representing the Line(row) whereas the green color area representing the Star printing.
• Line can be represented either in increasing order(1,2,3,4,5) or in decreasing order(5,4,3,2,1).
• In the given pattern, first-line is printing 1 star, second-line is printing 2 stars, third-line is printing 3 stars, and so on. Now you can see in the green area, we have mentioned it like 1 to 1, 1 to 2, 1 to 3, 1 to 4, and 1 to 5.
• Now match the common patterns from both(blue area and green area), here you can see we have matched it with red color box.
• Now as we have selected lines in increasing order(1,2,3,4,5), so we can write it like 1 to n and then it can be further assumed as the variable i.
• Similarly in the green area, we can write it like 1 to i and then it can be further assumed as the vriable j.
• Now we can write a for loop for the variable i is like for(int i=1; i<=n; i++){ …} to change the line and another for loop for the variable j is like for(int j=1; j<=i; j++){ …} to print the star. Hence, here we required only two for loops to print the given pattern.

Let’s see the complete logic below:

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Outer loop for the line/row change
for(int i=1; i<=n; i++) {

// Inner loop for the star printing
for(int j=1; j<=i; j++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

### Trick-2

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

Let’s develop the logic for it:

Let understand the above steps:

Step-1:

• Given pattern

Step-2:

• The given pattern can be converted in to the box format like the above.
• The box format is repersented in Rows(1,2,3,4,5) and Columns(1,2,3,4,5).

Step-3:

• Let’s assume n=5 (required number of rows).
• Here also the blue color area representing the Line(row) whereas the green color area representing the Star printing.
• Line can be represented either in increasing order(1,2,3,4,5) or in decreasing order(5,4,3,2,1).
• In the given pattern, first-line is printing 5 star, second-line is printing 4 stars, third-line is printing 3 stars, and so on. Now you can see in the green area, we have mentioned it like 1 to 5, 1 to 4, 1 to 3, 1 to 2, and 1 to 1.
• Now match the common patterns from both(blue area and green area), here you can see we have matched it with red color box.
• Now as we have selected lines in decreasing order(5,4,3,2,1), so we can write it like n to 1 and then it can be further assumed as the variable i.
• Similarly in the green area, we can write it like 1 to i and then it can be further assumed as the vriable j.
• Now we can write a for loop for the variable i is like for(int i=n; i>=1; i–){ …} to change the line and another for loop for the variable j is like for(int j=1; j<=i; j++){ …} to print the star. Hence, here also we required only two for loops to print the given pattern.

Let’s see the complete logic below:

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Outer loop for the line/row change
for(int i=n; i>=1; i--) {

// Inner loop for the star printing
for(int j=1; j<=i; j++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

### Trick-3

Follow the below steps to develop the logic:

Let me explain the above steps:

Step-1:

• Given pattern

Step-2:

• The given pattern can be converted in to the box format like the above.
• The box format is repersented in Rows(1,2,3,4,5) and Columns(1,2,3,4,5).

Step-3:

• Let’s assume n=5(required number of rows).
• In the above image, the blue color area representing the Line(row), the grey color area representing the Space printing, and the green color area representing the Star printing.
• As we have seen already the Line can be represented either in increasing order(1,2,3,4,5) or in decreasing order(5,4,3,2,1).
• In the pattern, first-line is printing 4 spaces, second-line is printing 3 spaces, third-line is printing 2 spaces, and so on. Now look at gray area we have mentioned it like 1 to 4, 1 to 3, 1 to 2, 1 to 1, and 1 to 0. Now just understand here, 4 can be written as 5-1 means 4=5-1, that’s why you can see in the first line we have written it like 1 to 4 = 5 – 1, similarly we can write for the reamining lines.
• In the pattern, first-line is printing 1 star, second-line printing 2 stars, third-line printing 3 stars, and so on. Now you can see in the green area, we have mentioned it like 1 to 1, 1 to 2, 1 to 3, 1 to 4, and 1 to 5.
• Now match the common patterns from all(blue area, grey area, and green area), here you can see we have matched it with red color box.
• Now as we have selected lines in increasing order(1,2,3,4,5), so we can write it like 1 to n and then it can be further assumed as the variable i.
• In grey area, we can write 1 to ( n-i ) and then it can be further assumed as the variable j.
• Similarly in the green area, we can write it like 1 to i and then it can be further assumed as the vriable k.
• Now we can write a for loop for the variable i is like for(int i=1; i<=n; i++){ …} to change the line and a for loop for the variable j is like for(int j=1; j<=( n-i ); j++){ …} to print the spaces, and another for loop for the variable k is like for(int k=1; k<=i; k++){ … } to print the stars. Hence, here we required three for loops to print the given pattern.

Let’s see the complete logic below:

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Outer loop for the line/row change
for(int i=1; i<=n; i++) {

// Inner loop1 for the space printing
for(int j=1; j<=(n-i); j++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop2 for the star printing
for(int k=1; k<=i; k++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

### Trick-4

Follow the below steps to develop the logic:

Let me explain the above steps:

Step-1:

• Given pattern

Step-2:

• The given pattern can be converted in to the box format like the above.
• The box format is repersented in Rows(1,2,3,4,5) and Columns(1,2,3,4,5).

Step-3:

• Let’s assume n=5(required number of rows).
• In the above image, the blue color area representing the Line(row), the grey color area representing the Space printing, and the green color area representing the Star printing.
• As we have seen already the Line can be represented either in increasing order(1,2,3,4,5) or in decreasing order(5,4,3,2,1).
• In the pattern, first-line is printing 0 space, second-line is printing 1 space, third-line is printing 2 spaces, and so on. Now look at gray area we have mentioned it like 1 to 0, 1 to 1, 1 to 2, 1 to 3, and 1 to 4. Now just understand here, 0 can be written as 5-5 means 0=5-5, that’s why you can see in the first line we have written it like 1 to 0 = 5 – 5, similarly we can write for the reamining lines.
• In the pattern, first-line is printing 5 star, second-line printing 4 stars, third-line printing 3 stars, and so on. Now you can see in the green area, we have mentioned it like 1 to 5, 1 to 4, 1 to 3, 1 to 2, and 1 to 1.
• Now match the common patterns from all(blue area, grey area, and green area), here you can see we have matched it with red color box.
• Now as we have selected lines in decreasing order(5,4,3,2,1), so we can write it like n to 1 and then it can be further assumed as the variable i.
• In grey area, we can write 1 to ( n-i ) and then it can be further assumed as the variable j.
• Similarly in the green area, we can write it like 1 to i and then it can be further assumed as the vriable k.
• Now we can write a for loop for the variable i is like for(int i=n; i>=1; i–){ …} to change the line and a for loop for the variable j is like for(int j=1; j<=( n-i ); j++){ …} to print the spaces, and another for loop for the variable k is like for(int k=1; k<=i; k++){ … } to print the stars. Hence, here also we required three for loops to print the given pattern.

Let’s see the complete logic below:

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Outer loop for the line/row change
for(int i=n; i>=1; i--) {

// Inner loop1 for the space printing
for(int j=1; j<=(n-i); j++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop for the star printing
for(int k=1; k<=i; k++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

### Trick-5

Follow the below steps to develop the logic:

Let me explain the above steps:

Step-1:

• Given pattern

Step-2:

• The given pattern can be converted in to the box format like the above.
• The box format is repersented in Rows(1,2,3,4,5) and Columns(1,2,3,4,5).

Step-3:

• Let’s assume n=5(required number of rows).
• In the above image, the blue color area representing the Line(row), the grey color area representing the Space printing, and the green color area representing the Star printing.
• As we have seen already the Line can be represented either in increasing order(1,2,3,4,5) or in decreasing order(5,4,3,2,1).
• In the pattern, first-line is printing 4 spaces, second-line is printing 3 spaces, third-line is printing 2 spaces, and so on. Now look at gray area we have mentioned it like 1 to 4, 1 to 3, 1 to 2, 1 to 1, and 1 to 0. Now just understand here, 4 can be written as 5-1 means 4=5-1, that’s why you can see in the first line we have written it like 1 to 4 = 5 – 1, similarly we can write for the reamining lines.
• In the pattern, first-line is printing 1 star, second-line printing 3 stars, third-line printing 5 stars, and so on. Now you can see in the green area, we have mentioned it like 1 to 1, 1 to 3, 1 to 5, 1 to 7, and 1 to 9. Now understand again here, 1 can also be written as (2*1)-1, that’s why you can see in the first line we have written it like 1 to 1 = (2*1) – 1, similarly we can write for the reamining lines.
• Now match the common patterns from all(blue area, grey area, and green area), here you can see we have matched it with red color box.
• Now as we have selected lines in increasing order(1,2,3,4,5), so we can write it like 1 to n and then it can be further assumed as the variable i.
• In grey area, we can write 1 to ( n-i ) and then it can be further assumed as the variable j.
• Similarly in the green area, we can write it like 1 to (2*i)-1 and then it can be further assumed as the vriable k.
• Now we can write a for loop for the variable i is like for(int i=1; i<=n; i++){ …} to change the line and a for loop for the variable j is like for(int j=1; j<=( n-i ); j++){ …} to print the spaces, and another for loop for the variable k is like for(int k=1; k<=(2*i)-1; k++){ … } to print the stars. Hence, here also we required three for loops to print the given pattern.

Let’s see the complete logic below:

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Outer loop for the line/row change
for(int i=1; i<=n; i++) {

// Inner loop1 for the space printing
for(int j=1; j<=(n-i); j++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop2 for the star printing
for(int k=1; k<=(2*i)-1; k++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

### Trick-6

Follow the below steps to develop the logic:

Let me explain the above steps:

Step-1:

• Given pattern

Step-2:

• The given pattern can be converted in to the box format like the above.
• The box format is repersented in Rows(1,2,3,4,5) and Columns(1,2,3,4,5).

Step-3:

• Let’s assume n=5(required number of rows).
• In the above image, the blue color area representing the Line(row), the grey color area representing the Space printing, and the green color area representing the Star printing.
• As we have seen already the Line can be represented either in increasing order(1,2,3,4,5) or in decreasing order(5,4,3,2,1).
• In the pattern, first-line is printing 0 space, second-line is printing 1 space, third-line is printing 2 spaces, and so on. Now look at gray area we have mentioned it like 1 to 0, 1 to 1, 1 to 2, 1 to 3, and 1 to 4. Now just understand here, 4 can be written as 5-1 means 4=5-1, that’s why you can see in the first line we have written it like 1 to 4 = 5 – 1, similarly we can write for the reamining lines.
• In the pattern, first-line is printing 9 stars, second-line printing 7 stars, third-line printing 5 stars, and so on. Now you can see in the green area, we have mentioned it like 1 to 9, 1 to 7, 1 to 5, 1 to 3, and 1 to 1. Now understand again here, 9 can also be written as (2*5)-1, that’s why you can see in the first line we have written it like 1 to 9 = (2*5) – 1, similarly we can write for the reamining lines.
• Now match the common patterns from all(blue area, grey area, and green area), here you can see we have matched it with red color box.
• Now as we have selected lines in decreasing order(5,4,3,2,1), so we can write it like n to 1 and then it can be further assumed as the variable i.
• In grey area, we can write 1 to ( n-i ) and then it can be further assumed as the variable j.
• Similarly in the green area, we can write it like 1 to (2*i)-1 and then it can be further assumed as the vriable k.
• Now we can write a for loop for the variable i is like for(int i=n; i>=1; i–){ …} to change the line and a for loop for the variable j is like for(int j=1; j<=( n-i ); j++){ …} to print the spaces, and another for loop for the variable k is like for(int k=1; k<=(2*i)-1; k++){ … } to print the stars. Hence, here also we required three for loops to print the given pattern.

Let’s see the complete logic below:

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Outer loop for the line/row change
for(int i=n; i>=1; i--) {

// Inner loop1 for the space printing
for(int j=1; j<=(n-i); j++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop for the star printing
for(int k=1; k<=(2*i)-1; k++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

### Trick-7

Follow the below steps to develop the logic:

Let me explain the above steps:

Step-1:

• Given pattern

Step-2:

• The given pattern can be converted in to the box format. We have divided the pattern into two parts(star-1 and star-2) as you can see in the above image.
• The box format is repersented in Rows and Columns.

Step-3:

• Let’s assume n=5.
• In the above image, the blue color area representing the Line(row), the grey color area representing the Space printing, and the two green color area representing the Star-1 and Star-2 for printing stars.
• Line can be represented either in increasing order(1,2,3,4,5) or in decreasing order(5,4,3,2,1).
• Here we have divided the pattern into two parts(only for star printing). Now as you can see in both Star-1 and Star-2 area, first-line is printing 1 star, second-line is printing 2 stars, third-line is printing 3 stars, and so on. Now look at both green area we have mentioned it like 1 to 1, 1 to 2, 1 to 3, 1 to 4, and 1 to 5.
• Now look at grey area, first-line is printing 8 spaces, second-line printing 6 spaces, third-line printing 4 spaces, and so on. So we have mentioned it like 1 to 8, 1 to 6, 1 to 4, 1 to 2, and 1 to 0. Now understand here, 8 can also be written as 2*(5-1), that’s why in the first line we have written it like 1 to 8 = 2*(5-1), similarly we have written for the reamining lines.
• Now match the common patterns from all(blue area, grey area, and both green area), here you can see we have matched it with red color box.
• Now as we have selected lines in increasing order(1,2,3,4,5), so we can write it like 1 to n and then it can be further assumed as the variable i.
• Now in both green area, we can write 1 to i and then further we can assume as the variable j and l respectively.
• Now in grey area, we can write 1 to 2*( n-i ) and then it can be further assumed as the variable k.
• Now here we required 4 for loops(for the variable i,j,k,l) to print the given pattern.
• The loop for the variable i is like for(int i=1; i<=n; i++){ … }.
• The loop for the variable j is like for(int j=1; j<=i; j++){ … }.
• The loop for the variable k is like for(int k=1; k<=2*(n-i); k++){ … }.
• The loop for the variable l is like for(int l=1; l<=i; l++){ … }.

Let’s see the complete logic below:

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Outer loop for the line/row change
for(int i=1; i<=n; i++) {

// Inner loop1 for the star printing
for(int j=1; j<=i; j++) {

// Printing the star without changing the line
System.out.print("*");
}

// Inner loop2 for the space printing
for(int k=1; k<=2*(n-i); k++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop3 for the again star printing
for(int l=1; l<=i; l++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

### Trick-8

Follow the below steps to develop the logic:

Let me explain the above steps:

Step-1:

• Given pattern

Step-2:

• The given pattern can be converted in to the box format. We have divided the pattern into two parts(star-1 and star-2) as you can see in the above image.
• The box format is repersented in Rows and Columns.

Step-3:

• Let’s assume n=5.
• In the above image, the blue color area representing the Line(row), the grey color area representing the Space printing, and the two green color area representing the Star-1 and Star-2 for printing stars.
• Line can be represented either in increasing order(1,2,3,4,5) or in decreasing order(5,4,3,2,1).
• Here we have divided the pattern into two parts(only for star printing). Now as you can see in both Star-1 and Star-2 area, first-line is printing 5 stars, second-line is printing 4 stars, third-line is printing 3 stars, and so on. Now look at both green area we have mentioned it like 1 to 5, 1 to 4, 1 to 3, 1 to 2, and 1 to 1.
• Now look at grey area, first-line is printing 8 spaces, second-line printing 6 spaces, third-line printing 4 spaces, and so on. So we have mentioned it like 1 to 8, 1 to 6, 1 to 4, 1 to 2, and 1 to 0. Now understand here, 8 can also be written as 2*(5-1), that’s why in the first line we have written it like 1 to 8 = 2*(5-1), similarly we have written for the reamining lines.
• Now match the common patterns from all(blue area, grey area, and both green area), here you can see we have matched it with red color box.
• Now as we have selected lines in decreasing order(5,4,3,2,1), so we can write it like n to 1 and then it can be further assumed as the variable i.
• Now in both green area, we can write 1 to i and then further we can assume as the variable j and l respectively.
• Now in grey area, we can write 1 to 2*( n-i ) and then it can be further assumed as the variable k.
• Now here also we required 4 for loops(for the variable i,j,k,l) to print the given pattern.
• The loop for the variable i is like for(int i=n; i>=1; i–){ … }.
• The loop for the variable j is like for(int j=1; j<=i; j++){ … }.
• The loop for the variable k is like for(int k=1; k<=2*(n-i); k++){ … }.
• The loop for the variable l is like for(int l=1; l<=i; l++){ … }.

Let’s see the complete logic below:

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Outer loop for the line/row change
for(int i=n; i>=1; i--) {

// Inner loop1 for the star printing
for(int j=1; j<=i; j++) {

// Printing the star without changing the line
System.out.print("*");
}

// Inner loop2 for the space printing
for(int k=1; k<=2*(n-i); k++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop3 for the again star printing
for(int l=1; l<=i; l++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

## Uses of Tricks for other patterns

You have seen the 8 basic tricks to develop the logic for printing the patterns. Now, these tricks will help you to develop other types of pattern logic as well. Let’s see some of them for understanding:

### Example-1

To develop the logic for this, we required Trick-1 and Trick-2

Given Pattern Logic = Trick-1 + Trick-2

Let’s understand this with some simple steps:

Step-1:

First of all, convert this pattern into a box format(rows & columns) like the below image-

Step-2:

When we combine Trick-1 & Trick-2 patterns, we are getting one extra row in the middle of the pattern(represented by the red box). Here we can divide the pattern into two parts upper half & lower half. For the upper half, we will use Tick-1 and for the lower half, we will use Trick-2 to develop the logic.

Step-3:

While developing the logic, from the lower half we will skip the first row/line star printing. So in order to skip first row/line printing, we will initialize the loop count by decreasing it by 1.

Let’s see the complete logic for this pattern below:-

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Upper half
// Outer loop for the line/row change
for(int i=1; i<=n; i++) {

// Inner loop for the star printing
for(int j=1; j<=i; j++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}

// Lower half
// Outer loop for the line/row change
for(int i=(n-1); i>=1; i--) {

// Inner loop for the star printing
for(int j=1; j<=i; j++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

### Example-2

To develop the logic for this also, we required the Trick-1 and Trick-2

Given Pattern Logic = Trick-2 + Trick-1

Convert the pattern into a box format(rows & columns) like the below image-

Here everything will be the same as Example-1 but the only difference is Trick-2 logic should come first then Trick-1 logic.

Let’s see the complete logic for this pattern below:-

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Upper half
// Outer loop for the line/row change
for(int i=n; i>=1; i--) {

// Inner loop for the star printing
for(int j=1; j<=i; j++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}

// Lower half
// Outer loop for the line/row change
for(int i=2; i<=n; i++) {

// Inner loop for the star printing
for(int j=1; j<=i; j++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

### Example-3

To develop the logic for this, we required Trick-3 and Trick-4

Given Pattern Logic = Trick-3 + Trick-4

Let’s understand this with some simple steps:

Step-1:

First of all, convert this pattern into a box format(rows & columns) like the below image-

Here also when we combine Trick-3 & Trick-4 patterns, we will get one extra row in the middle of the pattern(represented by the red box). The pattern is divided into two parts upper half & lower half. For the upper half, we will use Tick-3 and for the lower half, we will use Trick-4 to develop the logic.

Step-2:

While developing the logic, from the lower half we will skip the first row/line star printing. So in order to skip first row/line printing, we will initialize the loop count by decreasing 1.

See the complete logic below-

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Upper half
// Outer loop for the line/row change
for(int i=1; i<=n; i++) {

// Inner loop1 for the space printing
for(int j=1; j<=(n-i); j++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop2 for the star printing
for(int k=1; k<=i; k++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}

// Lower half
// Outer loop for the line/row change
for(int i=(n-1); i>=1; i--) {

// Inner loop1 for the space printing
for(int j=1; j<=(n-i); j++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop2 for the star printing
for(int k=1; k<=i; k++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

### Example-4

To develop the logic for this, we required Trick-5 and Trick-6

Given Pattern Logic = Trick-5 + Trick-6

Let’s convert this pattern into a box format(rows & columns) like the below image-

Here also when we combine Trick-5 & Trick-6 patterns, we will get one extra row(represented by the red box). The pattern is divided into two parts upper half & lower half. For the upper half, we will use Tick-5 and for the lower half, we will use Trick-6 to develop the logic. Now while developing the logic, from the lower half we need to skip the first row/line star printing. So we should initialize the loop count by decreasing 1.

See the complete logic below-

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Upper half
// Outer loop for the line/row change
for(int i=1; i<=n; i++) {

// Inner loop1 for the space printing
for(int j=1; j<=(n-i); j++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop2 for the star printing
for(int k=1; k<=(2*i)-1; k++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}

// Lower half
// Outer loop for the line/row change
for(int i=n-1; i>=1; i--) {

// Inner loop1 for the space printing
for(int j=1; j<=(n-i); j++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop for the star printing
for(int k=1; k<=(2*i)-1; k++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

### Example-5

To develop the logic for this also, we required Trick-5 and Trick-6 only

Given Pattern Logic = Trick-6 + Trick-5

Let’s convert this pattern into a box format(rows & columns) like the below image-

Here everything will be the same as Example-4 but the only difference is Trick-6 logic should come first then Trick-5 logic.

See the complete logic below-

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Upper half
// Outer loop for the line/row change
for(int i=n; i>=1; i--) {

// Inner loop1 for the space printing
for(int j=1; j<=(n-i); j++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop for the star printing
for(int k=1; k<=(2*i)-1; k++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}

// Lower half
// Outer loop for the line/row change
for(int i=2; i<=n; i++) {

// Inner loop1 for the space printing
for(int j=1; j<=(n-i); j++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop2 for the star printing
for(int k=1; k<=(2*i)-1; k++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

### Example-6

To develop the logic for this, we required Trick-7 and Trick-8

Given Pattern Logic = Trick-7 + Trick-8

Let’s convert this pattern into a box format(rows & columns) like the below image-

Here also when we combine Trick-7 & Trick-8 patterns, we will get one extra row(represented by the red box). The pattern is divided into two parts upper half & lower half. For the upper half, we will use Tick-7 and for the lower half, we will use Trick-8 to develop the logic. Now while developing the logic, from the lower half we need to skip the first row/line star printing. So we should initialize the loop count by decreasing 1.

See the complete logic below-

```package com.javacodepoint.patterns;

public class StarPattern {

// Main Method
public static void main(String[] args) {

// Initializing required number of lines/rows
int n = 5;

// Upper half
// Outer loop for the line/row change
for(int i=1; i<=n; i++) {

// Inner loop1 for the star printing
for(int j=1; j<=i; j++) {

// Printing the star without changing the line
System.out.print("*");
}

// Inner loop2 for the space printing
for(int k=1; k<=2*(n-i); k++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop3 for the again star printing
for(int l=1; l<=i; l++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}

// Lower half (skip the first line printing)
// Outer loop for the line/row change
for(int i=n-1; i>=1; i--) {

// Inner loop1 for the star printing
for(int j=1; j<=i; j++) {

// Printing the star without changing the line
System.out.print("*");
}

// Inner loop2 for the space printing
for(int k=1; k<=2*(n-i); k++) {

// Printing the space without changing the line
System.out.print(" ");
}

// Inner loop3 for the again star printing
for(int l=1; l<=i; l++) {

// Printing the star without changing the line
System.out.print("*");
}

// Line/Row change
System.out.println();
}
}

}

```

## Conclusion

In this article, you have seen 8 simple pattern printing tricks with a clear explanation. You have also seen that with the help of these tricks you can able to develop logic for other pattern printing programs.

With the help of these tricks, you can also develop the logic for Character Pattern programs and Number Pattern programs.

You can learn top 30 star pattern programs logic here: Top 30 star pattern programs in java