Programmes de motifs de pyramide en Java

Les programmes de motifs sont largement utilisés lors des entretiens pour comprendre les capacités de réflexion logique du candidat. Les motifs en forme de pyramide sont très populaires et une fois que nous comprenons la logique de leur création, écrire du code pour obtenir le même résultat est une tâche facile.

Programmes de Motifs de Pyramide en Java

Je fournis ici quelques exemples pour créer différents motifs de pyramide à partir de nombres, de symboles, etc. Nous examinerons également quelques exemples de création de motifs de pyramide inversée dans un programme Java. Nous essaierons de garder le code simple pour qu’il puisse être facilement compris.

Modèle de Pyramide de Nombres

Si vous regardez le premier motif, chaque ligne contient le même nombre imprimé le même nombre de fois. Cependant, chaque ligne a des espaces blancs en tête dont le nombre est « lignes-i ». Regardons le programme pour imprimer ce motif.

package com.journaldev.patterns.pyramid;

import java.util.Scanner;

public class PyramidPattern {

	private static void printPattern1(int rows) {
		// Boucle for pour les lignes
		for (int i = 1; i <= rows; i++) {
			// Espaces blancs devant les nombres
			int numberOfWhiteSpaces = rows - i;

			// imprimer les espaces blancs initiaux
			printString(" ", numberOfWhiteSpaces);

			// imprimer les nombres
			printString(i + " ", i);

			// passer à la ligne suivante
			System.out.println("");
		}
	}

	// fonction utilitaire pour imprimer une chaîne un certain nombre de fois
	private static void printString(String s, int times) {
		for (int j = 0; j < times; j++) {
			System.out.print(s);
		}
	}

	public static void main(String[] args) {

		Scanner scanner = new Scanner(System.in);
		System.out.println("Please enter the rows to print:");
		int rows = scanner.nextInt();
		// System.out.println("Lignes = "+rows);
		scanner.close();

		System.out.println("Printing Pattern 1\n");
		printPattern1(rows);

	}

}

Remarquez que j’ai créé une fonction utilitaire pour la tâche courante d’impression de chaînes. Si vous pouvez diviser votre programme en petites fonctions réutilisables, cela montre que vous ne cherchez pas seulement à écrire le programme mais aussi à garantir sa qualité et sa réutilisabilité. Lorsque nous exécutons le programme ci-dessus, nous obtenons la sortie suivante.

Please enter the rows to print:
9
Printing Pattern 1

        1 
       2 2 
      3 3 3 
     4 4 4 4 
    5 5 5 5 5 
   6 6 6 6 6 6 
  7 7 7 7 7 7 7 
 8 8 8 8 8 8 8 8 
9 9 9 9 9 9 9 9 9 

Modèle de pyramide de nombres croissants

Voici la fonction pour imprimer le motif 2. Le point clé à noter est le nombre d’espaces blancs initiaux et ensuite les nombres sont imprimés dans l’ordre croissant.

/**
 * 
 * Program to print below pyramid structure
 *      1         
       1 2        
      1 2 3       
     1 2 3 4      
    1 2 3 4 5     
   1 2 3 4 5 6    
  1 2 3 4 5 6 7   
 1 2 3 4 5 6 7 8  
1 2 3 4 5 6 7 8 9 
*/
private static void printPattern2(int rows) {
	// Boucle for pour les lignes
	for (int i = 1; i <= rows; i++) {
		// Espaces blancs devant les nombres
		int numberOfWhiteSpaces = rows - i;

		// imprimer les espaces blancs initiaux
		printString(" ", numberOfWhiteSpaces);

		// imprimer les nombres
		for(int x = 1; x<=i; x++) {
			System.out.print(x+" ");
		}

		// passer à la ligne suivante
		System.out.println("");
	}
}

Pyramide de caractères

C’est vraiment simple, il suffit d’imprimer le caractère sans aucun calcul ou manipulation.

/**
 * Program to print following pyramid structure
        *         
       * *        
      * * *       
     * * * *      
    * * * * *     
   * * * * * *    
  * * * * * * *   
 * * * * * * * *  
* * * * * * * * * 

*/
private static void printPattern3(int rows) {
	// boucle for pour les lignes
	for (int i = 1; i <= rows; i++) {
		// espaces blancs devant les chiffres
		int numberOfWhiteSpaces = rows - i;

		// imprime les espaces blancs
		printString(" ", numberOfWhiteSpaces);

		// imprime le caractère
		printString("* ", i);

		// passe à la ligne suivante
		System.out.println("");
	}
}

Programme Motif Pyramide 4

/**
* 
*               1 
              1 2 1 
            1 2 3 2 1 
          1 2 3 4 3 2 1 
        1 2 3 4 5 4 3 2 1 
      1 2 3 4 5 6 5 4 3 2 1 
    1 2 3 4 5 6 7 6 5 4 3 2 1 
  1 2 3 4 5 6 7 8 7 6 5 4 3 2 1 
1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1 
*/

private static void printPattern4(int rows) {
	// boucle for pour les lignes
	for (int i = 1; i <= rows; i++) {
		// espaces blancs devant les chiffres
		int numberOfWhiteSpaces = (rows-i)*2;

		// imprime les espaces blancs
		printString(" ", numberOfWhiteSpaces);

		// imprime les chiffres
		for(int x=1; x0; j--) {
			System.out.print(j+" ");
		}

		// passe à la ligne suivante
		System.out.println("");
	}
}

Remarquez que chaque ligne comporte 2*r-1 chiffres. Nous aurons donc (lignes-i)*2 espaces blancs avant d’imprimer un chiffre. Ensuite, les chiffres vont de 1 à « i », puis de 1 à nouveau. Notre logique d’impression des chiffres nécessiterait deux boucles for pour y parvenir.

Programme Motif Pyramide 5 en Java

/**
 * 
 *                9 
                8 9 8 
              7 8 9 8 7 
            6 7 8 9 8 7 6 
          5 6 7 8 9 8 7 6 5 
        4 5 6 7 8 9 8 7 6 5 4 
      3 4 5 6 7 8 9 8 7 6 5 4 3 
    2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 
  1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1 
*/
private static void printPattern5(int rows) {
	// boucle for pour les lignes
	for (int i = rows; i >= 1; i--) {
		// espaces blancs devant les chiffres
		int numberOfWhiteSpaces = i*2;

		// imprime les espaces blancs
		printString(" ", numberOfWhiteSpaces);

		// imprime les chiffres
		for(int x=i; x=i; j--) {
			System.out.print(j+" ");
		}

		// passe à la ligne suivante
		System.out.println("");
	}
}

Modèle de pyramide inversée de caractères

Voici un extrait de code pour le programme de pyramide inversée.

/**
 * 
* * * * * * * * * 
 * * * * * * * * 
  * * * * * * * 
   * * * * * * 
    * * * * * 
     * * * * 
      * * * 
       * * 
        * 
 */
private static void printPattern6(int rows) {
	// boucle for pour les lignes
	for (int i = rows; i >= 1; i--) {
		// espaces blancs devant les chiffres
		int numberOfWhiteSpaces = rows - i;

		// imprimer les espaces blancs initiaux
		printString(" ", numberOfWhiteSpaces);

		// imprimer le caractère
		printString("* ", i);

		// passer à la ligne suivante
		System.out.println("");
	}
}

Modèle de pyramide inversée de nombres

Examinons un exemple de modèle de pyramide inversée composée de nombres.

	/**
	 * 
9 9 9 9 9 9 9 9 9 
 8 8 8 8 8 8 8 8 
  7 7 7 7 7 7 7 
   6 6 6 6 6 6 
    5 5 5 5 5 
     4 4 4 4 
      3 3 3 
       2 2 
        1 
	 */
private static void printPattern7(int rows) {
	// boucle for pour les lignes
	for (int i = rows; i >= 1; i--) {
		// espaces blancs devant les chiffres
		int numberOfWhiteSpaces = rows - i;

		// imprimer les espaces blancs initiaux
		printString(" ", numberOfWhiteSpaces);

		// imprimer le caractère
		printString(i+" ", i);

		// passer à la ligne suivante
		System.out.println("");
	}
}

Conclusion

Il existe de nombreux types de motifs de pyramide. Le point le plus important est de comprendre le modèle dans lequel les chiffres et les espaces blancs sont organisés. Une fois que vous avez compris le motif, vous pouvez facilement écrire du code en Java ou dans n’importe quel autre langage de programmation. Faites-moi savoir si vous recherchez un programme de motif spécifique, et je ferai de mon mieux pour vous aider.

Lecture complémentaire

Programmes de chaînes en Java et Questions d’entretien en programmation Java

Vous pouvez consulter le code complet et d’autres exemples de programmation dans notre Dépôt GitHub.