C/Visual C - Necesito ayuda urgente

 
Vista:

Necesito ayuda urgente

Publicado por Carlos Arce (1 intervención) el 22/10/2001 08:31:15
Necesito ayuda urgente para implementar el juego del gato en c++, utilizando matrices no he podido realizar las escrituras ni lectura ayuda por favor es urgente
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Implementación del juego del gato (tres en raya) en C++

Publicado por Alejandro (913 intervenciones) el 17/10/2024 17:15:32
Aquí tienes un ejemplo básico de cómo implementar el juego del gato (o tres en raya) en C++ utilizando matrices. Este programa permite a dos jugadores jugar alternando turnos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#include <iostream>
 
using namespace std;
 
const int SIZE = 3; // Tamaño de la matriz
char board[SIZE][SIZE]; // Tablero del juego
 
// Función para inicializar el tablero
void inicializarTablero() {
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            board[i][j] = ' '; // Espacios vacíos
        }
    }
}
 
// Función para mostrar el tablero
void mostrarTablero() {
    cout << "  0 1 2\n"; // Encabezado de columnas
    for (int i = 0; i < SIZE; i++) {
        cout << i << " "; // Encabezado de filas
        for (int j = 0; j < SIZE; j++) {
            cout << board[i][j];
            if (j < SIZE - 1) cout << "|"; // Separador de columnas
        }
        cout << endl;
        if (i < SIZE - 1) {
            cout << "  -----\n"; // Separador de filas
        }
    }
}
 
// Función para verificar si hay un ganador
bool verificarGanador(char jugador) {
    // Verificar filas y columnas
    for (int i = 0; i < SIZE; i++) {
        if ((board[i][0] == jugador && board[i][1] == jugador && board[i][2] == jugador) ||
            (board[0][i] == jugador && board[1][i] == jugador && board[2][i] == jugador)) {
            return true;
        }
    }
    // Verificar diagonales
    if ((board[0][0] == jugador && board[1][1] == jugador && board[2][2] == jugador) ||
        (board[0][2] == jugador && board[1][1] == jugador && board[2][0] == jugador)) {
        return true;
    }
    return false;
}
 
// Función principal
int main() {
    inicializarTablero();
    char jugador = 'X'; // Jugador inicial
    int fila, columna;
    int movimientos = 0;
 
    while (true) {
        mostrarTablero();
        cout << "Turno del jugador " << jugador << ". Ingrese fila y columna (0-2): ";
        cin >> fila >> columna;
 
        // Validar entrada
        if (fila < 0 || fila >= SIZE || columna < 0 || columna >= SIZE || board[fila][columna] != ' ') {
            cout << "Movimiento inválido. Intente de nuevo." << endl;
            continue;
        }
 
        // Realizar el movimiento
        board[fila][columna] = jugador;
        movimientos++;
 
        // Verificar si hay un ganador
        if (verificarGanador(jugador)) {
            mostrarTablero();
            cout << "¡El jugador " << jugador << " ha ganado!" << endl;
            break;
        }
 
        // Verificar si hay un empate
        if (movimientos == SIZE * SIZE) {
            mostrarTablero();
            cout << "¡Es un empate!" << endl;
            break;
        }
 
        // Cambiar de jugador
        jugador = (jugador == 'X') ? 'O' : 'X';
    }
 
    return 0;
}

Explicación del programa:



1. Inicialización del tablero: La función `inicializarTablero` llena la matriz con espacios vacíos.

2. Mostrar el tablero: La función `mostrarTablero` imprime el estado actual del tablero en la consola.

3. Verificación de ganador: La función `verificarGanador` comprueba si el jugador actual ha ganado, verificando filas, columnas y diagonales.

4. Juego principal: En el `main`, se alternan los turnos entre los jugadores 'X' y 'O', se validan las entradas y se actualiza el tablero. El juego termina cuando hay un ganador o un empate.

Compilación y ejecución:



Guarda el código en un archivo llamado `gato.cpp` y compílalo usando un compilador de C++ como g++. Usa el siguiente comando:

1
2
g++ gato.cpp -o gato
./gato

¡Buena suerte con tu implementación, Carlos!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar