Pyramidenmusterprogramme in Java

Musterprogramme werden in Vorstellungsgesprächen häufig verwendet, um die logischen Denkfähigkeiten des Bewerbers zu verstehen. Pyramidenmuster sind sehr beliebt und sobald wir die Logik hinter ihrer Erstellung verstehen, ist es eine einfache Aufgabe, Code zu schreiben, um dasselbe zu erreichen.

Pyramidenmusterprogramme in Java

Hier gebe ich einige Beispiele, um verschiedene Pyramidenmuster aus Zahlen, Symbolen usw. zu erstellen. Wir werden uns auch einige Beispiele für die Erstellung eines umgekehrten Pyramidenmusters im Java-Programm ansehen. Wir werden versuchen, den Code einfach zu halten, damit er leicht verständlich ist.

Pyramidenmuster aus Zahlen

Wenn Sie sich das erste Muster ansehen, enthält jede Zeile dieselbe Zahl, die dieselbe Anzahl von Malen gedruckt wird. Jede Zeile enthält jedoch führende Leerzeichen, deren Anzahl „rows-i“ ist. Schauen wir uns das Programm an, um dieses Muster zu drucken.

package com.journaldev.patterns.pyramid;

import java.util.Scanner;

public class PyramidPattern {

	private static void printPattern1(int rows) {
		// for loop für die Zeilen
		for (int i = 1; i <= rows; i++) {
			// Leerzeichen vor den Zahlen
			int numberOfWhiteSpaces = rows - i;

			//führende Leerzeichen drucken
			printString(" ", numberOfWhiteSpaces);

			//Zahlen drucken
			printString(i + " ", i);

			//zu nächster Zeile wechseln
			System.out.println("");
		}
	}

	//Hilfsfunktion zum Drucken von Zeichenfolgen entsprechend oft
	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("Rows = "+rows);
		scanner.close();

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

	}

}

Beachten Sie, dass ich eine Hilfsfunktion für häufige Zeichendruckaufgaben erstellt habe. Wenn Sie Ihr Programm in kurze wiederverwendbare Funktionen aufteilen können, zeigt dies, dass Sie nicht nur das Programm schreiben möchten, sondern auch auf Qualität und Wiederverwendbarkeit achten. Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

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 

Pyramidenmuster mit steigenden Zahlen

Hier ist die Funktion zum Drucken von Muster 2. Der Schlüsselpunkt ist die Anzahl der führenden Leerzeichen und dann werden die Zahlen in aufsteigender Reihenfolge gedruckt.

/**
 * 
 * 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) {
	// for loop für die Zeilen
	for (int i = 1; i <= rows; i++) {
		// Leerzeichen vor den Zahlen
		int numberOfWhiteSpaces = rows - i;

		//führende Leerzeichen drucken
		printString(" ", numberOfWhiteSpaces);

		//Zahlen drucken
		for(int x = 1; x<=i; x++) {
			System.out.print(x+" ");
		}

		//zu nächster Zeile wechseln
		System.out.println("");
	}
}

Pyramide aus Zeichen

Das ist wirklich einfach, wir müssen einfach den Zeichen ohne Berechnungen oder Manipulationen drucken.

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

*/
private static void printPattern3(int rows) {
	// for-Schleife für die Zeilen
	for (int i = 1; i <= rows; i++) {
		// Leerzeichen vor den Zahlen
		int numberOfWhiteSpaces = rows - i;

		// führende Leerzeichen drucken
		printString(" ", numberOfWhiteSpaces);

		// Zeichen drucken
		printString("* ", i);

		// zur nächsten Zeile wechseln
		System.out.println("");
	}
}

Pyramid Pattern 4 Programm

/**
* 
*               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) {
	// for-Schleife für die Zeilen
	for (int i = 1; i <= rows; i++) {
		// Leerzeichen vor den Zahlen
		int numberOfWhiteSpaces = (rows-i)*2;

		// führende Leerzeichen drucken
		printString(" ", numberOfWhiteSpaces);

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

		// zur nächsten Zeile wechseln
		System.out.println("");
	}
}

Beachten Sie, dass jede Zeile 2*r-1 Zahlen hat. Daher haben wir (Zeilen-i)*2 Leerzeichen, bevor wir irgendeine Zahl drucken. Dann beginnen die Zahlen von 1 bis „i“ und dann wieder zu 1. Unsere Logik zum Drucken der Zahlen erfordert zwei for-Schleifen, um dies zu erreichen.

Pyramid Pattern 5 Programm in 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) {
	// for-Schleife für die Zeilen
	for (int i = rows; i >= 1; i--) {
		// Leerzeichen vor den Zahlen
		int numberOfWhiteSpaces = i*2;

		// führende Leerzeichen drucken
		printString(" ", numberOfWhiteSpaces);

		// Zahlen drucken
		for(int x=i; x=i; j--) {
			System.out.print(j+" ");
		}

		// zur nächsten Zeile wechseln
		System.out.println("");
	}
}

Invertiertes Pyramidenmuster von Zeichen

Hier ist der Codeausschnitt für das invertierte Pyramidenprogramm.

/**
 * 
* * * * * * * * * 
 * * * * * * * * 
  * * * * * * * 
   * * * * * * 
    * * * * * 
     * * * * 
      * * * 
       * * 
        * 
 */
private static void printPattern6(int rows) {
	// for-Schleife für die Zeilen
	for (int i = rows; i >= 1; i--) {
		// Leerzeichen vor den Zahlen
		int numberOfWhiteSpaces = rows - i;

		// Führende Leerzeichen drucken
		printString(" ", numberOfWhiteSpaces);

		// Zeichen drucken
		printString("* ", i);

		// Zum nächsten Zeile
		System.out.println("");
	}
}

Invertiertes Pyramidenmuster von Zahlen

Hier ist ein Beispiel für ein invertiertes Pyramidenmuster aus Zahlen.

	/**
	 * 
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) {
	// for-Schleife für die Zeilen
	for (int i = rows; i >= 1; i--) {
		// Leerzeichen vor den Zahlen
		int numberOfWhiteSpaces = rows - i;

		// Führende Leerzeichen drucken
		printString(" ", numberOfWhiteSpaces);

		// Zeichen drucken
		printString(i+" ", i);

		// Zum nächsten Zeile
		System.out.println("");
	}
}

Schlussfolgerung

Es gibt viele Arten von Pyramidenmustern. Der wichtigste Punkt ist zu verstehen, wie Zahlen und Leerzeichen im Muster organisiert sind. Sobald Sie das Muster verstanden haben, können Sie auch leicht Code in Java oder einer anderen Programmiersprache schreiben. Lassen Sie mich bitte wissen, wenn Sie nach einem bestimmten Musterprogramm suchen, und ich werde versuchen, Ihnen zu helfen.

Weiterführende Lektüre

String-Programme in Java und Java-Programmierfragen für Vorstellungsgespräche

Sie können den vollständigen Code und weitere Programmierbeispiele aus unserem GitHub-Repository überprüfen.