Introduction aux modèles en Java
Dans l'article Patterns in Java, avant d'apprendre tout langage de programmation en Java et de plonger profondément dans les concepts avancés, il est très important et avant tout de comprendre le fonctionnement des boucles. Bien qu'il existe 3 types de boucles pour les boucles while, do et 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. Pour utiliser diverses boucles, il faut une certaine logique de programmation et à cet effet, une pratique des modèles est donnée aux programmeurs car elle implique l'utilisation de la puissance logique et de raisonnement. Il peut s'agir de l'impression de figures géométriques (comme des triangles, des carrés, etc.), des pyramides, des boîtes dans divers motifs d'étoiles, des nombres, des styles de caractères sur l'écran de la console. Le format ou la syntaxe de base des boucles peut différer d'un langage de programmation à un autre mais la logique générale pour imprimer ces modèles reste la même.
Exemple de modèles en Java
Voyons comment dessiner des modèles en Java à travers quelques exemples
Exemple 1: impression d'une demi-pyramide à l'aide de nombres.
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();
)
)
)
Production:
Dans l'exemple ci-dessus, seules 2 boucles de base sont nécessaires pour imprimer le motif, la première boucle for correspond au nombre de lignes. Dans notre cas, nous avons défini les lignes, c'est-à-dire 5, sinon nous pouvons également prendre l'entrée de l'utilisateur et la stocker dans une variable. La boucle intérieure consiste à imprimer les nombres dans une ligne particulière. Après la fin 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();
)
)
)
Production:
Dans l'exemple ci-dessus, nous devons diviser la flèche en deux moitiés et utiliser 2 boucles pour chaque moitié. Dans la première moitié du nombre de lignes, la valeur initiale définie pour les lignes est alors que pour le nombre de demi-lignes inférieur, il est inférieur de 1 à la valeur initiale. Des boucles internes pour les deux moitiés sont utilisées pour parcourir chaque ligne en fonction de la boucle externe.
Exemple3: 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();
)
)
)
Production:
Dans l'exemple ci-dessus, nous devons faire 3 choses, c'est-à-dire en gardant à l'esprit le nombre total de lignes pour l'impression de la pyramide pour laquelle la première boucle for fonctionne de 1 à variable de lignes. 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 boucles for, on utilise des boucles situées à l'intérieur de la boucle externe «i».
Exemple 4: impression d'une demi-pyramide inversée à l'aide de nombres.
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();
)
)
)
Production:
La demi-pyramide simple est facile car nous devons gérer les chiffres, * ou les caractères que nous imprimons, mais pour la pyramide inversée, nous devons d'abord imprimer les espaces et ensuite le motif qui est (*) dans notre cas. Donc 3 pour les boucles sont utilisées fonctionnant de manière similaire à celles dans le cas de la pyramide complète.
Exemple 5: impression d'une demi-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();
)
)
)
Production:
La pyramide est imprimée avec la même logique que celle utilisée dans l'exemple ci-dessus en utilisant 2 pour les boucles, 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 le traitement des données de caractères. 'A' a une valeur numérique 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: modèle d'impression 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();
)
)
)
Production:
Le motif de base suivi pour traiter la valeur de caractère et les 2 boucles pour 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();
)
)
)
Production:
Pour l'impression du carré, nous avons besoin de la longueur et de la largeur, c'est-à-dire que les deux côtés du carré doivent être identiques, ce qui est 5 dans notre cas. Ainsi, la première boucle for est utilisée pour la longueur ou le nombre de lignes du carré et la boucle for interne est utilisée pour la largeur du carré, c'est-à-dire 5 étoiles sur une seule ligne.
Exemple 8: Impression d'un rectangle à l'aide d'étoiles (*).
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();
)
)
)
Production:
La logique de base de l'impression du rectangle de (*) est la même que l'impression des carrés, la seule différence entre les différentes longueurs et largeurs du rectangle. Ici, la boucle «i» correspond à la longueur du rectangle et la boucle intérieure «j» à la largeur de la boucle. Dans notre programme, il est considéré comme une valeur constante, nous pouvons également demander à l'utilisateur et les stocker dans des variables distinctes.
Exemple 9: Impression d'un diamant à l'aide d'étoiles.
L'impression d'un diamant en Java est un processus très simple. Il s'agit d'imprimer 2 pyramides, 1 dans le sens ascendant et une autre dans le sens inversé. Donc, fondamentalement, nous devons utiliser les boucles de la même manière que nous faisons le codage pour imprimer deux pyramides distinctes.
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();
)
)
)
Dans l'exemple ci-dessus, presque la même logique est appliquée pour créer les deux pyramides, une dans une direction ascendante et une autre dans une direction inversée. Le tout premier pour la boucle est pour le nombre de lignes ou de lignes dans le motif et deux autres pour les boucles sont pour les espaces et le motif d'étoiles (*) dans le motif.
Production:
Exemple 10: Impression de nombres binaires dans un format d'escalier.
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();
)
)
)
Production:
Dans l'exemple ci-dessus, afin d'imprimer un motif binaire, la boucle externe pour «i» est utilisée pour le nombre total de lignes et la boucle interne pour «j» est utilisée pour itérer jusqu'à la boucle externe «i» car pour la 1ère ligne nous avons besoin de 1 valeur, pour la 2ème ligne nous avons besoin de 2 valeurs, et ainsi de suite. Si et sinon, des instructions sont utilisées pour imprimer une valeur alternative de 0 et 1. Supposons que pour la première fois i = 1, j = 1 et 1% 2! = 0, alors 1 est imprimé et l'exécution sortira de la Boucle intérieure.
Exemple 11: programme pour imprimer un motif alphabétique répétitif.
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();
)
)
)
Production:
Dans l'exemple ci-dessus, si nous observons chaque ligne de motif, nous devons d'abord imprimer l'alphabet dans l'ordre croissant, c'est-à-dire AB puis dans l'ordre inverse, c'est-à-dire AB A. Pour cela, nous avons besoin de 3 boucles, 1ère pour boucle pour le nombre total de lignes. 2ème boucle for pour imprimer les alphabets dans l'ordre croissant puis la 3ème boucle for qui reste à l'intérieur de la boucle externe "i" et imprime les alphabets sur la même ligne mais dans l'ordre inverse de la boucle "j".
Conclusion
L'exemple ci-dessus et leurs explications montrent clairement comment créer de tels modèles en Java. Bien que ces modèles semblent être difficiles au début, mais en les observant profondément sur la façon dont la répétition du modèle se produit sur une seule ligne et selon le nombre de boucles à utiliser, il devient facile de le faire concrètement. Aujourd'hui également dans les entretiens avec les grandes entreprises, les candidats sont invités à écrire la logique de schémas de niveaux de difficulté variables. Parce que cette création de modèle montre les connaissances de base en logique et en programmation d'un individu.
Article recommandé
Cela a été un guide pour les modèles en Java. Ici, nous discutons Introduction aux modèles en Java et les exemples de différents modèles avec sortie. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus -
- Motifs d'étoiles en Java
- Cadres en Java
- Disposition en Java
- Introduction aux modèles en PHP
- Modèles en JavaScript avec des exemples