impression d'un carré avec des diagonales

Pour élaborer un peu sur l'idée de @ EugeneSh.: Pensez-y de cette façon. Vous avez deux boucles dans lesquelles vous itérez sur (2n + 1) x (2n + 1) caractères dans la sortie. Chacun de ces éléments doit être l'un des suivants: + , - , | , \ , / , X ou il doit avoir un (un caractère d'espace).

Vous ne pouvez pas éviter d'imprimer tous ces (2n + 1) ^ 2 caractères. Alors - n'essayez pas. Décidez simplement, pour chacun d'eux, lequel il doit être. Formez les conditions appropriées et vérifiez-les. Vous l'avez déjà fait pour 3 des personnages possibles - faites le reste.

Le "truc" est que si aucune des conditions pour les caractères non-espace n'est remplie - vous imprimez un espace ( ).

PS - Vous voudrez peut-être envisager l'instruction switch () {...} pour ce faire, avec default: utilisé pour imprimer l'espace.

Les devoirs sont une exploration.

Vous essayez d'imprimer un objet qui aura un certain nombre de décisions. Vous devez coder pour chacun d'eux. Un code simple pour cela pourrait essayer l'approche consistant à «imprimer tous les caractères dans un carré, en décidant de ce que chacun devrait être». C'est votre approche jusque là. Ensuite, vous devez écrire si les déclarations et répondre correctement est-ce que j'imprime '+', '-', '|', '\', '/', 'X' ou ''?

Vous avez besoin de penser à chaque personnage dans l'ordre. Par exemple, votre premier test, if (i == 0 && (j == 0 || j == size * 2)) , mais vous devez le développer pour obtenir le '+' la dernière ligne également.

Une idée de base est d'abord de faire fonctionner quelque chose. Je vous suggère de commencer par votre code et d'ajouter des éléments au fur et à mesure. Voici un aperçu avec '+' fonctionnant:

int last = size * 2
for (int i = 0; i < last + 1; i++){
    for (int j = 0; j < last + 1; j++){
        if ((i == 0 || i == last) && (j == 0 || j == last) {
           ...

Une fois que vous l'avez imprimé le '+' aux quatre coins d'un carré, ajoutez la logique pour chaque autre caractère, vérifier que vous obtenez un carré avec les '-', '_', etc., correct.

Un autre point est qu'il existe d'autres moyens de résoudre le problème, et vous devriez explorer comment certains semblent moins sujets aux erreurs que d'autres. Par exemple, si vous modifiez votre plan en:

for (int i = 0;i < ((size * 2) + 1);i++){
    for (int j = 0; j < ((size * 2) + 1);j++){
        if ((i == 0 || i == size * 2) && (j == 0 || j == size * 2)){
            printf("+");
        }
        // more else if for '-', etc.
        else {
            printf(" ");
        }
    }
}

, vous constaterez peut-être que l'élimination des répétitions et des parenthèses le rend moins sujet aux erreurs. Notez ou gardez une trace des erreurs que vous faites.

Voici une version légèrement modifiée de votre programme qui imprime des espaces où vous ne spécifiez rien d'autre.

Vous pouvez l'utiliser comme point de départ.

+---+
|   |
|   |
|   |
|   |

Ceci imprime

#include <stdio.h>

int main(void)
{
    int size = 2;
    int i, j;
    char ch;

    for (int i = 0;i < ((size * 2) + 1);i++){
        for (int j = 0; j < ((size * 2) + 1);j++){
            ch = ' ';
            if (i == 0 && (j == 0 || j == size * 2)){
                ch = '+';
            }
            else if (i == 0 && j != i){
                ch = '-';
            }

            if (i > 0 && (j == 0 || j == size * 2)){
                ch = '|';
            }
            printf("%c", ch);
        }
        printf("\n");
    }

    return 0;
}

Pensez comme ça. Vous n'avez qu'à vous soucier de la première moitié plus le milieu. En effet, la seconde moitié est la même que la première mais inversée.

Ensuite, vous déterminez une formule pour savoir à quoi une ligne spécifique devrait ressembler, uniquement par quelle ligne il s'agit et le nombre total de lignes.

La première ligne est facile. C'est un + , 2n-1 - et un autre +.

Ensuite, chaque ligne sauf celle du milieu sera deux | , avec un \ et un / et un total de 2n-3 espaces. Si y est la ligne et que la deuxième ligne est indexée à 0, alors (2n-3) -2y espaces au milieu et y espaces à l'extérieur du milieu.

Enfin, nous avons la ligne du milieu qui est deux | , n-1 espaces, X , n-1 espaces, |.

Rassembler tout cela: p>

// First row
putchar('+');
for(int i=0; i<2*n-1; i++)
        putchar('-');
putchar('+');
putchar('\n');

// Those between
for(int y=0; y<n-1; y++) {
    putchar('|');
    for(int i=0; i<y; i++)
        putchar(' ');
    putchar('\\');
    for(int i=0; i<(2*n-3)-2*y; i++)
        putchar(' ');
    putchar('/');
    for(int i=0; i<y; i++)
        putchar(' ');
    putchar('|');
    putchar('\n');
}

// Middle row
putchar('|');
for(int i=0; i<n-1; i++)
    putchar(' ');
putchar('X');
for(int i=0; i<n-1; i++)
    putchar(' ');
putchar('|');
putchar('\n');

Ceci s'imprime correctement sur la ligne du milieu. Pour imprimer le reste, copiez simplement la boucle «Ceux entre» pour, mais changez en pour (int y = n-2; y> 0; y--) et changez de place sur \ et / . Enfin, copiez simplement le code de la première ligne.