Hohlmuster beherrschen: Ein umfassender Leitfaden mit Codebeispielen

Willkommen zu unserem umfassenden Leitfaden zum Erstellen verschiedener Hohlmuster mithilfe von Schleifen in der C-Programmierung! In diesem Tutorial gehen wir Schritt für Schritt durch, wie man 18 verschiedene Hohlmuster zeichnet. Diese Muster reichen von Grundformen wie Quadraten und Dreiecken bis hin zu komplexeren Formen wie Rauten, Sechsecken und Fünfecken. Jedes Muster wird mithilfe verschachtelter Schleifen erstellt, was es zu einer hervorragenden Übung für Anfänger macht, um Kontrollstrukturen in C zu üben. Lassen Sie uns eintauchen!

Den gesamten Code finden Sie in unserem GitHub-Repository.

Inhaltsverzeichnis

1. Einführung in verschachtelte Schleifen
2. Hohles Quadrat
3. Hohles rechtwinkliges Dreieck
4. Hohles umgekehrtes rechtwinkliges Dreieck
5. Hohles rechtsbündiges Dreieck
6. Hohles rechtsbündiges umgekehrtes Dreieck
7. Hohles rechtes Pascal-Dreieck
8. Hohles linkes Pascal-Dreieck
9. Hohles gleichseitiges Dreieck
10. Hohles umgekehrtes gleichseitiges Dreieck
11. Hohle Pyramide
12. Hohle umgekehrte Pyramide
13. Hohler Diamant
14. Hohle Sanduhr
15. Hohle Raute
16. Hohles Parallelogramm
17. Hohles Sechseck
18. Hohles Fünfeck
19. Hohles umgekehrtes Fünfeck
20. Fazit

Einführung in verschachtelte Schleifen

Bevor wir mit den Mustern beginnen, ist es wichtig, das Konzept der verschachtelten Schleifen zu verstehen. Eine verschachtelte Schleife ist eine Schleife innerhalb einer anderen Schleife. Diese Struktur ist besonders nützlich für die Handhabung mehrdimensionaler Arrays und für die Generierung von Mustern. In C sieht eine typische verschachtelte Schleifenstruktur so aus:

for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        // Code to execute
    }
}

Hohles Quadrat

Erklärung:

• Das hohle Quadratmuster besteht aus n Zeilen und n Spalten.
• Zeichen werden nur an den Rändern gedruckt (erste Zeile, letzte Zeile, erste Spalte und letzte Spalte).

int n = 5; // size of the square
char ch = '*';

printf("1. Hollow Square:\n");
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        if (i == 0 || i == n - 1 || j == 0 || j == n - 1) {
            printf("%c  ", ch);
        } else {
            printf("   ");
        }
    }
    printf("\n");
}

Ausgabe:

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

Hohles rechtwinkliges Dreieck

Erklärung:

• Das hohle rechtwinklige Dreiecksmuster beginnt mit einem Zeichen in der ersten Reihe und erhöht sich in jeder folgenden Reihe um ein Zeichen.
• Zeichen werden nur an den Rändern gedruckt (erste Reihe, letzte Reihe und die Diagonale).

printf("2. Hollow Right Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = 0; j < i + 1; j++) {
        if (i == n - 1 || j == 0 || j == i) {
            printf("%c  ", ch);
        } else {
            printf("   ");
        }
    }
    printf("\n");
}

Ausgabe:

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

Hohles umgekehrtes rechtwinkliges Dreieck

Erklärung:

• Das hohle umgekehrte rechtwinklige Dreiecksmuster beginnt mit n Zeichen in der ersten Zeile und verringert sich in jeder folgenden Zeile um ein Zeichen.
• Zeichen werden nur an den Rändern gedruckt (erste Reihe, letzte Reihe und die Diagonale).

printf("3. Hollow Inverted Right Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = n; j > i; j--) {
        if (i == 0 || j == n || j == i + 1) {
            printf("%c  ", ch);
        } else {
            printf("   ");
        }
    }
    printf("\n");
}

Ausgabe:

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

Hohles, rechtsbündiges Dreieck

Erklärung:

• Das hohle, rechtsbündige Dreiecksmuster ähnelt dem hohlen, rechtwinkligen Dreieck, aber das Dreieck ist rechtsbündig.
• Zeichen werden nur an den Rändern gedruckt (erste Reihe, letzte Reihe und die Diagonale).

printf("4. Hollow Right Aligned Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = n - 1; j > i; j--) {
        printf("   ");
    }
    for (int j = 0; j < i + 1; j++) {
        if (i == n - 1 || j == 0 || j == i) {
            printf("%c  ", ch);
        } else {
            printf("   ");
        }
    }
    printf("\n");
}

Ausgabe:

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

Hohles, rechtsbündiges, umgekehrtes Dreieck

Erklärung:

• Das hohle, rechtsbündige umgekehrte Dreiecksmuster ist das Gegenteil des hohlen, rechtsbündigen Dreiecks.
• Es beginnt mit n Zeichen in der ersten Zeile und verringert sich in jeder folgenden Zeile um ein Zeichen, aber das Dreieck ist rechtsbündig.

printf("5. Hollow Right Aligned Inverted Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = 1; j < i + 1; j++) {
        printf("   ");
    }
    for (int j = n; j > i; j--) {
        if (i == 0 || j == n || j == i + 1) {
            printf("%c  ", ch);
        } else {
            printf("   ");
        }
    }
    printf("\n");
}

Ausgabe:

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

Hohles rechtes Pascal-Dreieck

Erklärung:

• Das hohle rechtwinklige Pascal-Dreieckmuster kombiniert das rechtwinklige Dreieck und das umgekehrte rechtwinklige Dreieck zu einem Pascal-ähnlichen Dreieck.
• Zeichen werden nur an den Rändern gedruckt (erste Reihe, letzte Reihe und die Diagonalen).

printf("6. Hollow Right Pascal Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = 0; j < i + 1; j++) {
        if (j == 0 || j == i) {
            printf("%c  ", ch);
        } else {
            printf("   ");
        }
    }
    printf("\n");
}
for (int i = 0; i < n; i++) {
    for (int j = n; j > i + 1; j--) {
        if (j == n || j == i + 2) {
            printf("%c  ", ch);
        } else {
            printf("   ");
        }
    }
    printf("\n");
}

Ausgabe:

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

Hohles linkes Pascal-Dreieck

Erklärung:

• Das Muster des hohlen linken Pascal-Dreiecks ähnelt dem hohlen rechten Pascal-Dreieck, ist jedoch linksbündig.
• Zeichen werden nur an den Rändern gedruckt (erste Reihe, letzte Reihe und die Diagonalen).

printf("7. Hollow Left Pascal Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = n - 1; j > i; j--) {
        printf("   ");
    }
    for (int j = 0; j < i + 1; j++) {
        if (j == 0 || j == i) {
            printf("%c  ", ch);
        } else {
            printf("   ");
        }
    }
    printf("\n");
}

for (int i = 0; i < n; i++) {
    for (int j = 0; j < i + 1; j++) {
        printf("   ");
    }
    for (int j = n - 1; j > i; j--) {
        if (j == n

 - 1 || j == i + 1) {
            printf("%c  ", ch);
        } else {
            printf("   ");
        }
    }
    printf("\n");
}

Ausgabe:

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

Hohles gleichseitiges Dreieck

Erklärung:

• Das hohle gleichseitige Dreiecksmuster ist symmetrisch und zentriert.
• Zeichen werden nur an den Rändern gedruckt (erste Reihe, letzte Reihe und die Diagonalen).

printf("8. Hollow Equilateral Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = n - 1; j > i; j--) {
        printf("   ");
    }
    for (int j = 0; j < 2 * i + 1; j++) {
        if (j == 0 || j == 2 * i || i == n - 1) {
            printf("%c  ", ch);
        } else {
            printf("   ");
        }
    }
    printf("\n");
}

Ausgabe:

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

Hohles umgekehrtes gleichseitiges Dreieck

Erklärung:

• The hollow inverted equilateral triangle pattern is the opposite of the hollow equilateral triangle.
• Characters are printed only at the borders (first row, last row, and the diagonals).

printf("9. Hollow Inverted Equilateral Triangle:\n");
for (int i = 0; i < n; i++) {
    for (int j = 0; j < i; j++) {
        printf("   ");
    }
    for (int j = 2 * n - 1; j > 2 * i; j--) {
        if (j == 2 * n - 1 || j == 2 * i + 1 || i == 0) {
            printf("%c  ", ch);
        } else {
            printf("   ");
        }
    }
    printf("\n");
}

Output:

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

Hollow Pyramid

Explanation:

• The hollow pyramid pattern is centered and symmetrical.
• Characters are printed only at the borders (first row, last row, and the diagonals).

printf("10. Hollow Pyramid:\n");
for (i = 0; i < n; i++) {
    for (j = n - 1; j > i; j--) {
       printf(" ");
    }
    for (j = 0; j < (2 * i + 1); j++) {
        if (i == n - 1 || j == 0 || j == i * 2 ) {
            printf("%c", ch);
        } else {
            printf(" ");
        }
    }
    printf("\n"); 
}

Output:

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

Hollow Inverted Pyramid

Explanation:

• The hollow inverted pyramid pattern is the opposite of the hollow pyramid.
• Characters are printed only at the borders (first row, last row, and the diagonals).

printf("11. Hollow Inverted Pyramid:\n");
for (i = n; i > 0; i--) {
    for (j = n - i; j > 0; j--) {
        printf(" ");
    }
    for (j = 0; j < (2 * i - 1); j++) {
        if (j == 0 || i == n  || j == (i-1) * 2 ) {
            printf("%c", ch);
        } else {
            printf(" ");
        }
    }
  printf("\n");
}

Output:

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

Hollow Diamond

Explanation:

• The hollow diamond pattern is symmetrical and centered.
• It consists of a hollow upper and lower triangle.

printf("12. Hollow Diamond:\n");
for (i = 0; i < n; i++) {
    for (j = n - 1; j > i; j--) {
        printf(" ");
    }
    for (j = 0; j < i + 1; j++) {
        if (j == 0 || j == i) {
            printf("%c ", ch);
        } else {
            printf("  ");
        }
    }
    printf("\n");
}
for (i = 0; i < n; i++) {
    for (j = 0; j < i + 1; j++) {
        printf(" ");
    }
    for (j = n - 1; j > i; j--) {
        if (j == n - 1 || j == i + 1) {
            printf("%c ", ch);
        } else {
            printf("  ");
        }
    }
    printf("\n");
}

Output:

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

Hollow Hourglass

Explanation:

• The hollow hourglass pattern is symmetrical and centered.
• It consists of a hollow upper and lower inverted triangle.

printf("13. Hollow Hourglass:\n");
for (i = 0; i < n; i++) {
    for (j = 0; j < i; j++) {
        printf(" ");
    }
    for (j = 0; j < (n - i) ; j++) {
        if (j == 0 || i == 0  || j ==  n - i - 1) {
            printf("%c ", ch);
        } else {
            printf("  ");
        }
    }
    printf("\n");
}
for (i = 1; i < n; i++) {
    for (j = n - 1; j > i; j--) {
       printf(" ");
    }
    for (j = 0; j < (i + 1); j++) {
       if (i == n - 1 || j == 0 || j == i) {
           printf("%c ", ch);
       } else {
           printf("  ");
       }
     }
     printf("\n");
}

Output:

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

Hollow Rhombus

Explanation:

• The hollow rhombus pattern is symmetrical and centered.
• Characters are printed only at the borders.

printf("14. Hollow Rhombus:\n");
for (int i = 0; i < n; i++) {
    for (int j = n - 1; j > i; j--) {
        printf("   ");
    }
    for (int j = 0; j < n; j++) {
        if (i == 0 || i == n - 1 || j == 0 || j == n - 1) {
            printf("%c  ", ch);
        } else {
            printf("   ");
        }
    }
    printf("\n");
}

Output:

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

Hollow Parallelogram

Explanation:

• The hollow parallelogram pattern is symmetrical and slanted to one side.
• Characters are printed only at the borders.

printf("15. Hollow Parallelogram:\n");
for (i = 0; i < n; i++) {
    for (j = 0; j < i; j++) {
        printf(" ");
    }
    for (j = 0; j < n * 2; j++) {
        if (i == n - 1 || i == 0 || j == 0 || j == n * 2 - 1) {
            printf("%c ", ch);
        } else {
            printf("  ");
        }
    }
    printf("\n");
}

Output:

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

Hollow Hexagon

Explanation:

• The hollow hexagon pattern consists of a combination of upper and lower triangles and a middle section.
• Characters are printed only at the borders.

printf("16. Hollow Hexagon:\n");
for (i = 0; i < n / 2; i++) {
    for (j = n / 2 - i; j > 0; j--) {
        printf(" ");
    }
    for (j = 0; j < n + 1 * i; j++) {
        if ( i == 0 || j == 0 || j == n * i) {
           printf("%c ", ch);
        } else {
           printf("  ");
        }
    }
    printf("\n");
}
for (i = n / 2; i >= 0; i--) {
    for (j = 0; j < n / 2 - i; j++) {
        printf(" ");
    }
    for (j = 0; j < n + i; j++) {
        if (i == n - 1 || i == 0 || j == 0 || j == n + i - 1) {
            printf("%c ", ch);
        } else {
            printf("  ");
        }
    }
    printf("\n");
}

Output:

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

Hollow Pentagon

Explanation:

• The hollow pentagon pattern consists of an upper triangle and a lower rectangle.
• Characters are printed only at the borders.

printf("17. Hollow Pentagon:\n");
for (i = 0; i < n+1; i++) {
    for (j = n ; j > i; j--) {
        printf(" ");
    }
    for (j = 0; j < (i + 1); j++) {
        if ( j == 0 || i == 0 || j == i ) {
            printf(" %c", ch);
        } else {
            printf("  ");
        }
    }
    printf("\n");
}
for (i = n / 2; i >= 0; i--) {
    for (j = 0; j < n / 2 - i; j++) {
        printf(" ");
    }
    for (j = 0; j < n +  i; j++) {
        if (i == n - 1 || i == 0 || j == 0 || j == n + i - 1) {
            printf("%c ", ch);
        } else {
            printf("  ");
        }
    }
    printf("\n");
}

Output:

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

Hollow Inverted Pentagon

Explanation:

• The hollow inverted pentagon pattern consists of an upper inverted triangle and a lower inverted rectangle.
• Characters are printed only at the borders.

printf("18. Hollow Inverted Pentagon:\n");
for (int i = 0; i <= n / 2; i++) {
    for (int j = 0; j < n / 2 - i; j++) {
        printf(" ");
    }
    for (int j = 0; j < n + i; j++) {
        if (i == n - 1 || i == 0 || j == 0 || j == n + i - 1) {
            printf("%c ", ch);
        } else {
            printf("  ");
        }
    }
    printf("\n");
}
for (int i = n + 1; i > 0; i--) {
    for (int j = n + 2; j > i; j--) {
        printf(" ");
    }
    for (int j = 0; j < i; j++) {
        if ( j == 0 || j == i - 1) {
            printf("%c ", ch);
        } else {
            printf("  ");
        }
    }
    printf("\n");
}

Output:

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

Conclusion

In conclusion, we have explored a variety of patterns using loops and conditional statements in C, each producing different geometric shapes and designs. These patterns include solid and hollow variants of squares, triangles, pyramids, diamonds, hourglasses, rhombuses, parallelograms, hexagons, and pentagons. Understanding and implementing these patterns helps to strengthen programming logic, loop constructs, and conditionals, which are fundamental concepts in computer science.

By practicing these patterns, you can enhance your problem-solving skills and improve your ability to visualize and implement complex patterns in code. These exercises also provide a solid foundation for more advanced programming tasks and algorithms.

Das obige ist der detaillierte Inhalt vonHohlmuster beherrschen: Ein umfassender Leitfaden mit Codebeispielen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!