C Jogo da velha em c

[Leanderson Pinheiro]

To fazendo um jogo da velha na linguagem C, entretanto eu queria otimizar ele porque se não vai ficar muito grande. No momento ele está assim, conferindo se X ou O ganhou, entretanto nem terminei os ifs para X e ainda tenho que fazer para O, ficaria imenso. Teria uma forma de otimizar e conferir a condição sem precisar de tantos ifs ?

 

 

#include <stdio.h>

int main (void)
{

    char l, i, j;
    char p;
    char m[3][3], soma = 0;

    for (i = 0; i < 3; i++){
            for (j= 0; j < 6; j++){
                scanf("%c", &m[i][j]);
            }

    }

    if(m[0][0]=='X' && m[1][0]=='X' && m[2][0]=='X'){
            printf("X\n");

    }

    if(m[0][1]=='X' && m[1][1]=='X' && m[2][2]=='X'){
            printf("X\n");

    }

    if(m[1][0]=='X' && m[2][0]=='X' && m[3][0]=='X'){
            printf("X\n");
    }

     if(m[1][1]=='X' && m[2][1]=='X' && m[3][1]=='X'){
            printf("X\n");
    }

     if(m[1][2]=='X' && m[2][2]=='X' && m[3][2]=='X'){
            printf("X\n");
    }
     if(m[1][3]=='X' && m[2][3]=='X' && m[3][3]=='X'){
            printf("X\n");
    }

    return 0;
}
 

 

[isrnick]

Uma maneira de reduzir pela metade os ifs seria simplesmente verificar se os casas adjacentes são iguais entre si, ao invés de checar se são iguais a 'X' ou 'O'. Por exemplo:

 

if(m[0][0]==m[1][0] && m[1][0]==m[2][0])

Assim não importa se a casa é 'X' ou 'O', só que tem 3 valores iguais (mas note que também precisa eliminar o caso em que as posições da matriz são iguais mas não foram preenchidas com 'X' nem 'O').

 

Fora isso seria necessário fazer usar ciclos while ou for para percorrer a matriz e checar as posições se quiser tentar reduzir mais.

[Leanderson Pinheiro]

@isrnick Então, eu queria usar algum laço de repetição para conseguir reduzir, poderia me explicar como fazer nesse caso ?

[isrnick]

Não reduz muito, poderia checar as 3 verticais assim:

for(int i=0; i<3; ++i){
    if(m[0][i]==m[1][i] && m[1][i]==m[2][i]){
        //....
    }
}

Aí tem que fazer outro loop para as horizontais, e para as diagonais vão ser só 2 ifs mesmo.

[kgin]

@Leanderson Pinheiro Poderia ser feito dessa maneira também.

int linhas, colunas, objeto, vezes;

    /* Checa as linhas */
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        vezes = 1;
        objeto = tabuleiro[linhas][0];
        for (colunas = 1; colunas < Q_COLUNAS; colunas++) {
            if (objeto == tabuleiro[linhas][colunas]) {
                vezes++;
            }
        }

        if ((vezes == Q_LINHAS)&&(objeto != TAB_VAZIO)) {
            return(objeto);
        }
    }

 

Código do exemplo.

Spoiler

#include <stdio.h>

#define Q_LINHAS 3
#define Q_COLUNAS 3

#define TAB_VAZIO 0
#define TAB_X 1
#define TAB_O 2
#define TAB_VELHA 3

void mostraTabuleiro(int tabuleiro[Q_LINHAS][Q_COLUNAS]);

int checaVitoria(int tabuleiro[Q_LINHAS][Q_COLUNAS]);

int main(void)
{
    int vitoria;
    /* Velha */
    int tabuleiro1[Q_LINHAS][Q_COLUNAS] = {{1,2,1},
                                           {2,1,1},
                                           {1,2,2}};

    /* X */
    int tabuleiro2[Q_LINHAS][Q_COLUNAS] = {{1,2,1},
                                           {2,1,1},
                                           {1,2,1}};

    /* O */
    int tabuleiro3[Q_LINHAS][Q_COLUNAS] = {{2,2,1},
                                           {1,2,1},
                                           {1,2,2}};

    printf("\ntabuleiro 1\n");
    mostraTabuleiro(tabuleiro1);
    vitoria = checaVitoria(tabuleiro1);
    switch (vitoria) {
        case TAB_O:
            printf("Vitoria do O\n");
            break;

        case TAB_X:
            printf("Vitoria do X\n");
            break;

        case TAB_VELHA:
            printf("Deu velha!\n");
            break;

        default:
            printf("Ninguem ganhou ainda!\n");
    }

    printf("\ntabuleiro 2\n");
    mostraTabuleiro(tabuleiro2);
    vitoria = checaVitoria(tabuleiro2);
    switch (vitoria) {
        case TAB_O:
            printf("Vitoria do O\n");
            break;

        case TAB_X:
            printf("Vitoria do X\n");
            break;

        case TAB_VELHA:
            printf("Deu velha!\n");
            break;

        default:
            printf("Ninguem ganhou ainda!\n");
    }

    printf("\ntabuleiro 3\n");
    mostraTabuleiro(tabuleiro3);
    vitoria = checaVitoria(tabuleiro3);
    switch (vitoria) {
        case TAB_O:
            printf("Vitoria do O\n");
            break;

        case TAB_X:
            printf("Vitoria do X\n");
            break;

        case TAB_VELHA:
            printf("Deu velha!\n");
            break;

        default:
            printf("Ninguem ganhou ainda!\n");
    }

    getchar();
    return(0);
}

void mostraTabuleiro(int tabuleiro[Q_LINHAS][Q_COLUNAS])
{
    int linhas, colunas;
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
            if (colunas < Q_COLUNAS-1) {
                if (tabuleiro[linhas][colunas] == TAB_X) {
                    printf("X|");
                } else {
                    printf("O|");
                }
            } else {
                if (tabuleiro[linhas][colunas] == TAB_X) {
                    printf("X");
                } else {
                    printf("O");
                }
            }
        }
        putchar('\n');
    }
}

int checaVitoria(int tabuleiro[Q_LINHAS][Q_COLUNAS])
{
    int linhas, colunas, objeto, vezes;

    /* Checa as linhas */
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        vezes = 1;
        objeto = tabuleiro[linhas][0];
        for (colunas = 1; colunas < Q_COLUNAS; colunas++) {
            if (objeto == tabuleiro[linhas][colunas]) {
                vezes++;
            }
        }

        if ((vezes == Q_LINHAS)&&(objeto != TAB_VAZIO)) {
            return(objeto);
        }
    }

    /* Checa as colunas */
    for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
        vezes = 1;
        objeto = tabuleiro[0][colunas];
        for (linhas = 1; linhas < Q_LINHAS; linhas++) {
            if (objeto == tabuleiro[linhas][colunas]) {
                vezes++;
            }
        }

        if ((vezes == Q_COLUNAS)&&(objeto != TAB_VAZIO)) {
            return(objeto);
        }
    }

    /* Checa a diagonal esquerda */
    /* X|_|_
     * _|X|_
     *  | |X
     */
    objeto = tabuleiro[0][0];
    vezes = 1;
    for (linhas = colunas = 1; linhas < Q_LINHAS || colunas < Q_COLUNAS; linhas++, colunas++) {
        if (objeto == tabuleiro[linhas][colunas]) {
            vezes++;
        }
    }

    if ((vezes == Q_LINHAS || vezes == Q_COLUNAS) && (objeto != TAB_VAZIO)) {
        return(objeto);
    }

    /* Checa a diagonal direita */
    /* _|_|X
     * _|X|_
     * X| |
     */
    objeto = tabuleiro[0][Q_COLUNAS-1];
    vezes = 1;
    for (linhas = 0, colunas = Q_COLUNAS-2; linhas < Q_LINHAS || colunas > 0; linhas++, colunas--) {
        if (objeto == tabuleiro[linhas][colunas]) {
            vezes++;
        }
    }

    if ((vezes == Q_LINHAS || vezes == Q_COLUNAS) && (objeto != TAB_VAZIO)) {
        return(objeto);
    }

    /* Checa se deu velha ou galo */
    vezes = 0;
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
            if (tabuleiro[linhas][colunas] == TAB_O || tabuleiro[linhas][colunas] == TAB_X) {
                vezes++;
            }
        }
    }

    if (vezes == (Q_LINHAS*Q_COLUNAS)) {
        return(TAB_VELHA);
    }

    /* Ninguém ganhou ainda */
    return(TAB_VAZIO);
}

 

 

[isrnick]

@kgin Sim, também usei esse método nesse jogo da velha:

Mas não reduz o código muito, a vantagem é que também funciona para tamanhos de velha maiores do que 3x3, mas esse é o tamanho padrão do jogo da velha.

[kgin]

14 minutos atrás, isrnick disse:

Mas não reduz o código muito, a vantagem é que também funciona para tamanhos de velha maiores do que 3x3, mas esse é o tamanho padrão do jogo da velha.

Se a minha memoria não me falha (que com certeza ela falha) eu acho que isso serve para aquele jogo chines chamado go também.

 

Eu dei uma olha do seu código e a ideia e realmente a mesma, mas aquele código do devair o cara tava aprendendo e criptografia porque eu não entendi nada daquele código dele.

[arfneto]

São só 8 resultados definitivos para o jogo da velha então pode separar em 4 casos

• final em alguma linha
• final em alguma coluna
• diagonal 1
• diagonal 2

E usar loops para esses casos.

 

Talvez possa ficar mais legível se usar uma função como

 

	char	vitoria( char dimensao, char* tabuleiro );

 

que retorne 

• '-' se ninguém ganhou ainda
• 'X' ou 'O' para a vitória de um desses

onde dimensao em geral será 3 e tabuleiro será o endereço de início do tabuleiro. Assim pode controlar e testar vários cenários ao mesmo tempo, como
 

	switch ( vitoria( 3, jogo1 )
	{
		case 'X':
		// X ganhou
		break;

		case 'O':
		break;

		default:
		break;
	}
...