Dans l'article Patterns in Java, avant d'apprendre un langage de programmation en Java et de plonger profondément dans les concepts avancés, il est important de comprendre le fonctionnement des boucles. Bien qu'il existe 3 types de boucles qui sont les boucles for, while et do-while. Chaque boucle est utilisée en fonction de la situation particulière d'un programme car elles sont légèrement différentes les unes des autres. L'utilisation de diverses boucles nécessite une certaine logique de programmation et, à cette fin, la pratique des modèles est donnée aux programmeurs car elle implique l'utilisation de la logique et du pouvoir de raisonnement. Par exemple, il peut s'agir d'imprimer des figures géométriques (comme des triangles, des carrés, etc.), des pyramides, des bo?tes avec divers motifs d'étoiles, de chiffres et de styles de caractères sur l'écran de la console. Le format ou la syntaxe de base des boucles peuvent différer d'un langage de programmation à l'autre, mais la logique générale pour imprimer ces motifs reste la même.

Exemple de modèles en Java

Comprenons comment dessiner des modèles en Java à travers quelques exemples

Exemple 1?: Imprimer la moitié de la pyramide à l'aide de chiffres.

Code?:

public class Pyramid
{
public static void main(String[] args)
{
int i, j;
?//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= 5; i++)
{
?//innermost loop is to print the numbers in the specific rows for (j=1; j<=i; j++)
{
System.out.print(j +" " );
}
System.out.println();
}
}
}

Sortie?:

Dans l'exemple ci-dessus, seules 2 boucles de base sont nécessaires pour imprimer le motif ; la première boucle for concerne le nombre de lignes. Dans notre cas, nous avons défini les lignes, soit 5, sinon nous pouvons également prendre l'entrée de l'utilisateur et la stocker dans une variable. La boucle interne consiste à imprimer les nombres dans une ligne particulière?; Après l'achèvement d'une ligne ou la fin de la boucle 'j', la ligne est modifiée à l'aide de println().

Exemple2?: Impression d'une flèche de chiffres.

Code?:

public class NumberTriangle
{
public static void main(String[] args)
{
int i, j;
int rows =7;
?//outermost loop to represent the number of rows which is 7 in this case
//for the upper half of arrow
for (i=1; i<= rows; i++)
{
?//innermost loop is to print the numbers in the specific rows
//for the upper half of arrow
for (j=1; j<=i; j++)
{
System.out.print(j + " ");
}
System.out.println();
}
?//outermost loop to represent the number of rows which is 6 in this case
//for the lower half of arrow
for (i=rows-1; i>=1; i--)
{
?//innermost loop is to print the numbers in the specific rows
//for the lower half of arrow
for (j=1; j<=i; j++)
{
System.out.print(j + " ");
}
System.out.println();
}
}
}

Sortie?:

?

Dans l'exemple ci-dessus, nous devons diviser la flèche en deux moitiés et utiliser 2 boucles pour chaque moitié. La première moitié des lignes serait la valeur initiale définie pour les lignes, tandis que le nombre de lignes est inférieur de 1 à la valeur initiale de la moitié inférieure. Les boucles intérieures des deux moitiés sont utilisées pour parcourir chaque ligne en fonction de la boucle extérieure.

Exemple 3?: Impression d'une pyramide complète à l'aide d'étoiles (*).

Code?:

public class FullPyramid
{
public static void main(String[] args)
{
int i, j, k;
int rows = 5;
//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= rows; i++)
{
//innermost loop to represent the spaces in pyramid for (j= 1; j<= rows-i; j++)
{
System.out.print(" ");
}
?//innermost loop to represent the stars (*) in pyramid for (k= 1; k<= 2*i-1; k++)
{
System.out.print("* ");
}
System.out.println();
}
}
}

Sortie?:

Dans l'exemple ci-dessus, nous devons faire 3 choses, c'est-à-dire garder à l'esprit le nombre total de lignes pour l'impression de la pyramide pour laquelle la première boucle for travaille de 1 à rows variable. Deuxièmement, nous devons d'abord imprimer les espaces dans la pyramide, puis le motif (*) après les espaces. Pour ces deuxième et troisième ?, des ?boucles for sont utilisées à l’intérieur de la boucle externe ??i??.

Exemple 4?: Impression d'une demi-pyramide inversée à l'aide de chiffres.

Code?:

public class ReversePyramid
{
public static void main(String[] args)
{
int i, j, k;
int rows = 5;
?//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= rows; i++)
{
//innermost loop to represent the spaces
for (j= 1; j<= rows-1; j++)
{
System.out.print(" ");
}
?//innermost loop to represent the stars (*) in pyramid for (k= 1; k<= i; k++)
{
System.out.print("* ");
}
System.out.println();
}
}
}

Sortie?:

La demi-pyramide simple est facile car nous devons gérer les nombres, * ou les caractères que nous imprimons, mais pour la pyramide inversée, nous devons d'abord imprimer les espaces puis le motif, qui est (*) dans notre cas . Ainsi, 3 boucles for sont utilisées, fonctionnant de la même manière que celles du cas de la pyramide complète.

Exemple 5?: Imprimer la moitié de la pyramide à l'aide d'alphabets.

Code?:

public class AlphabetPyramid
{
public static void main(String[] args)
{
int i, j;
?//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= 5; i++)
{
int ch = 65;
?//innermost loop to represent the alphabets in a pyramid in particular row for (j= 1; j<= i; j++)
{
System.out.print((char)(ch + i - 1) + " ");
}
System.out.println();
}
}
}

Sortie?:

La pyramide est imprimée avec la même logique que celle utilisée dans l'exemple ci-dessus, en utilisant 2 boucles for, une pour le nombre de lignes et d'autres pour l'impression des caractères dans une ligne particulière. Mais la principale chose à noter est la gestion des données de caractères. Par exemple, ??A?? a une valeur numérique de 65 en Java, donc toute la logique mathématique est effectuée en utilisant la valeur numérique de l'alphabet, et à la fin, elle est imprimée au format caractère.

Exemple 6?: Impression d'un motif d'alphabets.

Code?:

public class AlphabetPattern
{
public static void main(String[] args)
{
int i, j;
//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= 5; i++)
{
int ch = 65;
?//innermost loop to represent the alphabets for (j= 1; j<= i; j++)
{
System.out.print((char)(ch - 1 + j) + " ");
}
System.out.println();
}
}
}

Sortie?:

Le modèle de base suivi pour gérer la valeur du caractère et les 2 boucles for dans l'exemple ci-dessus est similaire à l'exemple 5, la seule différence étant la logique simple utilisée pour imprimer le motif souhaité.

Exemple 7?: Impression d'un carré à l'aide d'étoiles (*).

Code?:

public class SquarePattern
{
public static void main(String[] args)
{
int i, j;
?//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= 5; i++)
{
int ch = 65;
//innermost loop to represent the stars (*) for (j= 1; j<= 5; j++)
{
System.out.print(" * " + " ");
}
System.out.println();
}
}
}

Sortie?:

For printing of square, we need length and width, i.e. both sides of the square should be the same, which is 5 in our case. So the first ? ?loop is used for the length or number of rows in the square, and the inner ? ?loop is used for the width of the square, i.e. 5 stars in a single row.

Example 8: Printing rectangle using stars (*).

Code:

public class RectanglePattern
{
public static void main(String[] args)
{
int i, j;
?//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= 5; i++)
{
int ch = 65;
?//innermost loop to represent columns the stars (*) for (j= 1; j<= 9; j++)
{
System.out.print(" * " + " " );
}
System.out.println();
}
}
}

Output:

The basic logic of printing the rectangle of (*) is the same as printing of squares, the only difference between is the different length and width of the rectangle. Here ‘i’ loop is for the length of the rectangle, and the inner ‘j’ loop is for the width of the loop. Our program is taken as a constant value; we can also ask the user and store them in separate variables.

Example 9: Printing a Diamond using stars.

Printing a diamond in Java is a very simple process. It involves printing 2 pyramids, 1 in the upward direction and another in an inverted direction. Basically, we need to use the loops to do the coding to print two separate pyramids.

Code:

public class Diamond
{
public static void main(String[] args)
{
int i, j, k;
int rows = 5;
?//outermost loop to represent the number of rows which is 5 in this case.
// Creating upper pyramid
for(i= 1; i<= rows; i++)
{
//innermost loop to represent the spaces in upper pyramid for (j= 1; j<= rows-i; j++)
{
System.out.print(" ");
}
?//innermost loop to represent the stars (*) in upper pyramid for (k= 1; k<= 2*i-1; k++)
{
System.out.print("* ");
}
System.out.println();
}
?//outermost loop for the rows in the inverted pyramid for (i = rows-1; i>0; i--)
{
?//innermost loop for the space present in the inverted pyramid for (j=1; j<= rows - i; j++)
{
System.out.print(" ");
}
?//innermost loop inside the outer loop to print the ( * ) pattern in inverted pyramid for (k = 1; k<= 2*i-1; k++)
{
System.out.print("* ");
}
System.out.println();
}
}
}

In the above example, almost the same logic is applied to create both pyramids, one in an upward direction and another in an inverted direction. Thus, the first ?loop is for the number of lines or rows in the pattern, and the second is for spaces and the stars (*) pattern in the pattern.

Output:

Example 10: Printing binary numbers in a stair format.

Code:

public class BinaryStair
{
public static void main(String[] args)
{
int i, j;
//outer loop for the total rows which is 5 in this case for (i = 1; i <= 5; i++)
{
?//inner loop for the pattern of 0 and 1 in each row for (j = 1; j<= i ; j++)
{
if (j % 2 ==0)
{
System.out.print(0);
}
else
{
System.out.print(1);
}
}
System.out.println();
}
}
}

Output:

In the above example, in order to print binary pattern, outer ?for ?loop ‘i’ is used for a total number of rows, and the inner ?for ?loop ‘j’ is used to iterate till the outer loop ‘i’ because for the 1st row, we need 1 value, for the 2nd row we need 2 values, and so on. ?If? and else ?statements are used in order to print the alternate value of 0 and 1. Suppose for the first time i=1, j=1 and 1%2 != 0, then 1 is printed, and execution will move out of the inner loop.

Example 11: Program to print repeating alphabet patterns.

Code:

public class AlphabetReverseOrder
{
public static void main(String[] args)
{
int i, j, k;
//outer loop for the total rows which is 5 in this case for (i = 0 ; i<=5; i++)
{
int ch= 65;
//inner loop for the pattern of alphabets in till ‘i’ loop for (j = 0; j <=i ; j++)
{
System.out.print((char) (ch+j) + " ");
}
//inner loop for the pattern of alphabets in reverse order from ‘i’ loop for (k= i-1; k >=0; k--)
{
System.out.print((char) (ch+k) + " ");
}
System.out.println();
}
}
}

Output:

In the above example, if we observe each row of pattern, we need to print the alphabet first in the increasing order, i.e. A B and then in the reverse order, i.e. A B A. For this, we need 3 loops, 1st ?for? loop for the total number of rows. 2nd ?for? loop to print the alphabets in increasing order then the 3rd ?for? loop which remains inside the outer ‘i’ loop and prints the alphabets in the same line but in reverse order of ‘j’ loop.

Conclusion

The above example and their explanations clearly show how to make such patterns in Java. Though these patterns seem to be difficult in the starting, observing them deeply of how the repetition of pattern is happening in a single row and according to how many loops should be used, it becomes easy to do hands-on on this. Today also, in interviews of big companies, candidates are asked to write the logic of patterns of varying difficulty levels because this pattern making shows the basic logical and programming knowledge of an individual.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!