Hola y bienvenido.
Me gustaria dar una solucion para el desafío de tic tac toe.
Ahora recuerda, hay muchos soluciones a un problema dado.
Esta va a ser mi solución.
Si tu solución es diferente siempre que siga las buenas
prácticas de programación y utilice el lenguaje de programación c de la
manera correcta, entonces está bien.
Solo estoy brindando mi solución.
Estoy seguro de que se puede mejorar.
Entonces empecemos.
Voy a crear un nuevo proyecto se llama tic-tac-toe
obviamente, y vamos a empieza a intentar modularlo.
Traté de descomponerlo como lo hice en la descripción de la conferencia.
Voy a crear un solo algunos módulos o debería
decir algunas funciones.
Con suerte, esto será bien y funciona bien para ti.
Estoy usando caja de camello para todos mis nombres convenciones justo a lo que estoy acostumbrado.
Incluso podríamos separarnos esto en varios archivos de origen también
si quisiéramos.
Entonces tenemos nuestro main.
Deshagámonos de este printf.
Voy a incluir una inclusión adicional.
Esto me permitirá básicamente limpiar un poco nuestro sistema y un par
de cosas interesantes, permitir yo también creo que eliminar un char.
Entonces, además de estos 2 bibliotecas, incluyamos conio. h.
Y lo que quiero hacer y yo quiero atacar este problema.
Quiero intentar modulo tanto como pueda.
Mencioné que me voy para usar una
matriz unidimensional, una matriz bidimensional incluso podría funcionar mejor.
Pero voy a implementar esto usando
una matriz unidimensional que representa nuestro juego tablero, nuestro tablero tic-tac-toe.
Voy a crear esto como variable global.
Estoy usando una variable global aquí
porque no he demostrado el concepto de pasar datos por referencia en c.
No quiero confundirte.
No tendría que usar global datos aquí y
podría pasar los datos a las funciones, pero lo haría Necesito usar pasar por referencia.
Tendría que pasar punteros, y aún no hemos discutido
nada de eso.
Entonces voy a usar datos globales.
Perdóname, memoriza que los datos globales son por lo general,
no es algo bueno que hacer, pero porque, de nuevo, estamos tratando de Demostrar aprendizaje, dividir
conquistar y estamos tratando de demostrar cómo utilizar las funciones, necesito utilizar datos
globales porque todavía no he hablado de punteros.
Entonces, mis datos globales aquí que voy usar es mi cuadrado que representa
mi cuadrícula, mi tablero de tic-tac-toe.
Este va a ser un sencillo área dimensional de
10 elementos principalmente porque yo no quiero usar el elemento 0.
Voy a usar esta matriz para elegir números para jugar el juego.
También permitirá que tenga mis coordenadas.
Voy a inicializar esto con solo valores del 1 al 9.
Y esto va a ser un matriz de caracteres porque necesito
poner x y o en ella.
No hemos hablado de carácter matrices todavía, pero esto me permitirá
poner caracteres individuales.
Es como el concepto de matriz de ints excepto que contiene caracteres.
Personajes, recuerda, tienen comillas simples alrededor de ellos.
Entonces uno 2 3 9 el, 0 allí la o solo me voy a
saltar, ni siquiera la voy a usar, porque quiero usar los.
Facilita un poco la programación.
Puedo usar el valor que el usuario entra como un índice, como un índice válido.
Yo tambien voy a tener que crea 2 variables globales para elegir en
el turno del jugador.
Así que la elección será lo que ellos ingresado a través del teclado, ya sea
de uno a 9 dependiendo de dónde quieren colocar su xo o.
El jugador va a solo representan el turno de
quién es el jugador, el jugador uno o el jugador 2.
No necesito ningún otro dato global.
Solo necesito mi función declaraciones aquí.
Voy a empezar con la creación de 3 funciones.
Entonces voy a tener 3 declaraciones de funciones.
Voy a tener uno para buscar una victoria.
No va a necesitar ningún dato.
Devolverá un int.
Voy a tener uno que no devuelve cualquier dato que,
simplemente, muestre el tablero con los caracteres correctos.
Tampoco toma ningún dato.
Y también voy a tener un función que solo marca el tablero.
Esto tomará la entrada del usuario.
Y dependiendo de lo que entraron, colocará una xo o en el lugar correcto en
la matriz y luego mostrará esa matriz usando la placa de visualización.
Así que aquí solo vamos a decir tablero de marcas y eso va a tomar
una marca con una x o una o.
Entonces puedo reutilizar esto.
Puedo reutilizar esto para jugador uno o jugador 2.
3 declaraciones de funciones para que pueda coloco mis funciones en cualquier lugar
del programa, las he declarado arriba.
Y notarás que los 2 de estos las funciones no devuelven ningún
dato y solo una toma un parámetro.
Implementemos estas funciones antes de implementar el juego.
Así que primero, vamos implementar el cheque para ganar.
Esta función básicamente va a trabajar donde va a comprobar el tablero para ver
si hay alguna victoria.
Entonces va a contener muchas declaraciones if.
Probablemente podría mejorar este código bastante.
Pero voy a poner algunos comentarios aquí porque siempre deberíamos tener
comentarios en la parte superior de nuestra función.
Estos están bastante simplificados.
Deberíamos tener el nombre de la función.
Esto básicamente está diciendo que la función devolverá
un estado de juego de uno si el juego ha terminado, le dirá si ganó, un
resultado de uno negativo si el el juego está en progreso y 0 si el juego
terminó y fue un empate.
Así que esta función comprueba uno está devolviendo un int.
Así que me voy a ir adelante y defina esto.
Y todo lo que esto va a hacer es va
a mirar la matriz y ver si hay puntos allí, si coincide con 3x.
Entonces hay mucho diferentes declaraciones if.
Entonces, ¿cómo sabemos si un jugador es uno?
Bueno, sabemos si un jugador es uno si coinciden en una diagonal de fila
o en una columna.
Entonces tenemos que revisar cada una de esas situaciones.
Y conocemos las filas en el columnas basadas en la matriz.
Entonces, si mi cuadrado es igual al cuadrado 2 y
el cuadrado 2 es igual al cuadrado 3, eso significa que tener un partido en nuestra primera fila.
Así que también voy a cree un valor de retorno aquí.
En la parte superior, solo voy a decir valor de retorno, inicialice esto a 0.
Inicializaremos esto a 0 para finalizar el juego.
Y si tenemos un partido en la primera fila, voy
a devolver una, se acabó el juego.
Entonces tenemos que tener una serie de otros si coinciden y en realidad no
quiero volver uno quiero establecer mi valor de retorno.
Porque podríamos volver pero hace que el programa sea más difícil de seguir.
De lo contrario, vamos a compruebe todas nuestras otras filas.
Entonces voy a copiar y pegar algo de código
aquí porque es mucho código redundante.
Lo único que es interesante es si tenemos un empate.
Así que déjame poner todos los más si es para los ganadores.
Y luego también voy a devuelve valores diferentes.
En lugar de tener un montón de más si, podría tener símbolos de unión, pero
eso es aún más difícil de leer.
Entonces, si tenemos un partido en la primera fila.
Y asegurémonos de que nuestro la sangría es correcta.
Si tenemos una coincidencia en nuestra segunda fila, eso es lo que está haciendo el segundo.
Si tenemos una coincidencia en nuestra tercera fila, devuelva uno agregue algunas líneas nuevas para facilitar
la lectura, no necesita corchetes porque son declaraciones únicas.
En la línea 37, parece estamos haciendo coincidir uno, 4 y 7.
Entonces esto parece un coincidencia diagonal, devuelve uno.
Cuarenta, estamos haciendo coincidir 2 5 y 8.
Que parece un partido del centro bajando, por lo que la segunda columna.
3 6, puede ver el otros partidos también.
Tenemos que atrapar básicamente todos los partidos para filas, columnas y diagonales.
Y eso es lo que hemos hecho con todos estas declaraciones mirando en la matriz.
Ahora lo único que nos dice si no tenemos una coincidencia o tenemos un empate si
tenemos que compararlos todos y básicamente, asegúrese de que no sean los
números que se inicializaron.
Entonces, si tenemos nuestro cuadrado de matriz y no contiene 1 2 3 1 2 3 4 5
6 8 o 9 para ninguno de los valores, eso significa que tenemos un empate porque contienen
un 0 o una x.
Entonces, ¿podemos escribir otro más? si eso
básicamente dice que es un empate y podemos establecer el valor de retorno a 0, valor de retorno igual a 0.
Y de nuevo esto es básicamente marcando esto último si, si los números
son los mismos a medida que se inicializaron.
Si todos son diferentes, entonces eso significa que podemos devolver 0.
Pongamos eso.
De lo contrario, si no tenemos un empate y no tenemos un ganador, eso
significa que no hemos terminado.
Entonces, una declaración final de otra cosa solo puede decir el valor de retorno es igual a uno negativo.
Porque recuerda, la función es devolviendo negativo uno para el
juego en progreso uno para el juego ha terminado y 0 para juego sin resultado.
Y luego lo último que quiero hacer es que quiero devolver el valor de retorno.
Así que aquí solo voy a decir retorno, valor de retorno.
Y esto completará la función.
Y que notas cuando estamos haciendo esto, estamos
dividiendo y conquistando.
Todo lo que nos enfocamos bien ahora está revisando el tablero para ver si
hay una victoria.
Trabajaríamos en pequeño trozos como este y
probábamos constantemente.
Esto nos permite enfocarnos en nuestra diseño y también nos permite reducir o aislar
nuestros errores más fácilmente.
Ahora que hemos terminado con el tablero de juego, queremos seguir adelante
e implementar el tablero de visualización.
El tablero de la pantalla es solo voy a mostrar el tablero.
Entonces todo lo que esto realmente necesita hacer es dibuja la matriz en un formato específico.
Entonces vamos a escribir un función llamada tablero de visualización.
No devolverá ningún dato, no va a necesitar ningún parámetro.
La razón por la que es un número de
función uno es porque vamos a necesitar dibujar el tablero muchas veces y también es mejor
porque está realizando una tarea específica.
Ahora este solo va a tener un montón de funciones printf en él.
Y va a tener un montón de formato.
Así que voy a copiarlo y pegarlo.
Lo que es único aquí es Estoy limpiando la pantalla cada vez.
Pero si dices sistema y windows y dices cls, eso va a borrar
la pantalla.
Simplemente lo hace más limpio.
Entonces vamos a solo hacer un montón de printfs.
Vamos a imprimir el título del juego. Vamos a imprimir el jugador 1 y 0.
Y luego nos vamos para imprimir el tablero.
El tablero va a quedar bien formateado con algunas barras paralelas y
luego vamos a imprimir el valores de todos los valores de la matriz.
Y si el valor es xo 0, se mostrará.
Si no es así, mostrará un número para que podamos usar ese número para
seleccionar nuestra opción de dibujar y eso es eso, eso es todo lo que hace esta función.
Ahora que hemos terminado con mostrando el
tablero, ahora queremos crear nuestra última función que está marcando el tablero.
Así que el tablero de marca se va a poner la matriz con
un valor particular, y va a escribir una marca en una x o una o.
Entonces va a necesitar un personaje.
Lo que esto va a hacer es va a
tener un montón de otras declaraciones if.
Así que aquí en nuestro tablero de
marcas, estamos va a querer básicamente dar algunos comentarios y decir que esto va a
configurar el tablero con el carácter correcto xo o en el lugar correcto en la matriz.
Así que, con suerte, eso tiene sentido.
Como ves el código, yo Llegué a terminar mis comentarios.
Quiero formatearlo bien por lo que son 2 líneas aquí.
Y todo esto va a hacer va
a verificar para ver lo que ingresó el usuario.
Recuerde, tenemos 2 datos globales valores para lo que ingresó el usuario.
También tenemos un valor para el jugador actual.
Así que la elección será básicamente lo que se ingresa a través del teclado.
Aún no lo hemos implementado porque vamos a implementar eso
en la función principal.
El jugador va a ser el jugador actual.
Vamos a necesitar ambos de estos para dejar nuestras marcas.
Entonces, lo que vamos a hacer es va a tener un
montón de declaraciones else, declaraciones if else.
Vamos a comprobar la elección que es lo que ingresa el usuario.
Y si la elección es igual a 1, quiero dibujar algo en ese cuadrado.
También queremos asegurarnos que ese cuadrado está disponible.
Entonces, si es igual a 1 y no es actualmente igual a 1, eso
significa que básicamente alguien ya puso una x o una o allí y no podemos usarlo.
Si es igual a uno y ellos ingresado uno, eso significa que podemos establecer
la matriz en un valor específico.
Vamos a configurar la matriz a lo que se pasó en la o en la x.
Y vamos a repetir para hacer esto para cada elección.
Si se trata de opciones 2 3 4 5 6 8 o 9.
Así que un montón de otras cosas que hacen lo mismo.
Si el usuario ingresó la opción 2, estamos vamos a asegurarnos de que la
sangría sea buena y que el cuadrado 2 esté disponible, vamos a marcar la casilla 2 con lo que
hayamos pasado aquí.
Y dependiendo de qué jugador sea el turno es decir, vamos a pasar una o una x.
Ahora lo último que tenemos que hacer en esta función es la que tenemos que validar.
Si pasaron en algo que no sea del 1 al 9,
es un movimiento inválido.
Así que nuestra última declaración más Aquí imprimirá un mensaje que dice movimiento inválido, lo hará marca el
jugador menos uno.
Porque recuerda jugadores son uno o 2.
Y vamos a marcar al jugador hacia atrás y luego lo vamos a incrementar
en nuestro ciclo en nuestra función principal.
Y luego esta última cosa se pone char está pausando el programa para que
el usuario tenga que presionar volver después de una mudanza inválida.
De lo contrario, un movimiento inválido mostrarse y luego se borraría
inmediatamente porque volveríamos a dibujar el tablero de nuevo.
Así que get char lo pausa.
Te obliga a presionar el botón Enter para continuar ingresando otro valor.
Y estas son nuestras 3 funciones.
Recuerda, esta función no devuelve nada.
Entonces podemos mantenerlo en la parte inferior.
Ahora tenemos que realmente implementar el juego.
El juego va en la función principal.
Entonces, para el juego, aquí es donde vamos a pedirle al usuario que ingrese un
número, vamos a dibujar el tablero, vamos a comprobar si gana.
Entonces vamos a crear 2 variables locales aquí, y vamos
a inicializar nuestro reproductor.
Aquí vamos a crea nuestro entero I.
Esto se utilizará para nuestro bucle.
Y nuestra marca va a ser x u o, dependiendo de quién sea el turno.
Mark va a ser xo o, creo.
Mark va a ser xo o.
Y la elección va a ser lo que el usuario ingresa a través del teclado.
Entonces 2 variables locales.
También vamos a establecer nuestro player, que es una variable global.
Inicialmente, solo va a sé el jugador uno para comenzar el juego.
Entonces vamos a tener un bucle.
Vamos a tener un un bucle hasta que terminemos de jugar.
Voy a usar un do mientras bucle aquí porque quiero que
se ejecute al menos una vez.
Quiero mostrar el abordar al menos una vez.
Así que voy a mostrar el tablero y jugar
el juego hasta que consiga un empate básicamente o una victoria.
Así que lo voy a hacer mientras ya que yo es igual a menos 1.
¿Qué representa un 1 negativo? representa que el juego está en curso.
Voy a ser el regreso valor para comprobar si gana.
Y lo verás en un segundo pero básicamente cuando
tengo un bucle que sigue haciendo lo mismo una y otra vez hasta que se acabe el juego.
Y el juego va a ser sobre si no es negativo.
Entonces, ¿qué tenemos que hacer primero?
Lo primero que tenemos que hacer es tenemos que mostrar el tablero.
Entonces puedo llamar al tablero de visualización de funciones.
Entonces tenemos que calcular el jugador.
Y el jugador comienza con el jugador uno.
Lo que vamos a hacer
aqui es vamos a utilizar un operador ternario, y vamos a decir si el jugador mod 2, entonces
el jugador es igual a 1; de lo contrario, es igual a 2.
Esta es una forma de determinar el jugador correcto.
Cada iteración del bucle va para cambiar de uno a 2 o de 2 a uno.
Cuando comienza como el jugador uno, va a decir jugador mod
2, uno dividido por 2 o el resto de uno dividido por 2 es lo que, uno.
Entonces, si es uno, eres va a ser el jugador uno.
Y cuando vuelvas por el siguiente iteración, el
jugador será igual a 2 porque lo vamos a incrementar.
2 mod 2 es 0.
Entonces, si no es igual a uno, entonces el jugador será
igual al jugador 2.
Solo lo configurará en jugador uno si el mod de jugador 2 es uno.
Recuerda, ese tornero operador con suerte.
Lo siguiente que tengo que hacer es necesita obtener la entrada del usuario.
Así que aquí voy a decir, voy para pedirle al usuario que ingrese un número.
Voy a decir jugador porcentaje d ya sea jugador 1 o 2, ingrese un número, y luego voy a poner el
jugador para imprimir, jugador uno o 2.
Entonces voy a leer el entrada del usuario usando scanf.
Y eso va a ser un número entero eso representará un
lugar en el tablero del uno al 9.
Y voy a almacenar que en mi variable de elección.
La elección es una pulgada, así que yo tengo que pasar la dirección,
y tengo que decir elección.
Solo si es una cuerda lo haría no pasar en la dirección.
Entonces básicamente puedo determinar si o no cuál es la marca.
Tengo que determinar si la marca es una x o no según el jugador.
Entonces voy a usar el operador ternario de nuevo.
Y voy a asignar para marcar una x o una o.
Si el jugador es igual a 1, voy asignar para marcar la x, x mayúscula.
De lo contrario, voy a asígnele una o, o mayúscula.
Entonces este operador ternario es muy útil cuando tiene que asignar
variables basadas en una condición.
Una vez más, lo que esto está diciendo es si el jugador es igual
a 1, la marca será igual ax.
De lo contrario, será igual a o.
El signo de interrogación representa si la evaluación booleana es verdadera, los
dos puntos representan si es falsa.
Ahora que tengo la letra correcta Puedo llamar a mi
función para marcar el tablero con solo decir marcar tablero, pasando en la x o la o.
Después de marcar el tablero y ellos hizo su selección,
tengo que comprobar si hay un ganador.
Tengo mi variable yo que realmente
debería ser un nombre mejor.
Vamos a nombrarlo verificación de estado, juego compruebe qué tal eso o el estado del juego.
Y el estado del juego será igual a uno menos uno o 0.
El estado del juego va a ser igual a lo que se
devuelva del cheque para ganar.
Porque recuerde, esta función devuelve un uno a 0 o uno negativo.
Uno si el juego termina con el resultado, uno negativo si el juego está en curso, 0
si se acaba sin resultado.
Así que ahora que almacenamos el juego status, también queremos cambiar
la condición del bucle.
Entonces, si el estado del juego es igual a uno
negativo, saltaremos del bucle.
De lo contrario, todo lo que tenemos que hacer es cambiar el turno del jugador.
¿Cómo cambiamos el turno del jugador? simplemente incrementamos el jugador en uno.
De esa manera la próxima vez subirá y será 2, y el jugador
será igual a 2 y volveremos a bajar.
Cuando hacen intentos inválidos, ¿qué ocurre en las plantillas inválidas, disminuye
el recuento de jugadores.
Cuando disminuyes el recuento de jugadores, vuelve al reproductor correcto.
Entonces, si es uno, lo decretas a 0, el próximo turno será uno, es esencialmente
tu mismo turno de nuevo.
Por eso lo incrementamos.
Ahora si es el jugador 2, lo incrementamos en uno.
Y lo que pasa es 2 dividido 2 es 0.
Entonces realmente establece el jugador de nuevo a uno.
Así es como funciona.
Pero esta es toda la lógica.
Hicimos mucho aquí.
No deberías escribir todo este código y pruébelo a la vez.
Deberías haber estado trabajando con divide y vencerás, probando constantemente mientras
estás ejecutando el código.
Ahora voy a proporcionar esta solución, pero ejecutémosla
y probémosla.
Va a funcionar como lo hizo en la demostración de la conferencia del desafío.
Pero de nuevo, estudia este código y haz Seguro que entiendes lo que está pasando.
El uso de matrices y la división Conquistar el enfoque, pero mira qué bonito
se ve este método principal.
Es muy fácil saber lo que pasando en el método principal.
Tablero de anuncios, cambia de jugador y tú Probablemente quiera poner comentarios aquí.
Cambie de turno y luego también aquí obtén entrada.
Y luego configure el correcto letra, establezca el carácter correcto
según el turno del jugador.
Ni siquiera realmente necesitas estos comentarios porque
las funciones son muy descriptivas.
Marque el tablero, configure el tablero según la elección del usuario o la elección no válida.
Y luego la verificación del estado del juego para ganar, bastante autoexplicativo.
Y luego saltamos si el juego termina.
Construyamos esto.
Con suerte, no obtendrá errores, no advertencias, no lo hacemos, lo cual es bueno.
Ahora ejecutémoslo y vas a vea cómo funciona como en nuestra demostración.
Lo primero que hace es va a mostrar la pantalla.
Y va a permitir nosotros para imprimir una entrada.
Y tiene nuestra cuadrícula, una 2 3 4 5 6 7 8 9 nuestra matriz.
Entonces me dice el jugador uno ingrese algo y
estoy ingresando algo válido.
Y lo dibuja, y limpia la pantalla.
Entonces se ve bien.
Y ahora hay una x en 3.
Ahora es el turno del jugador 2.
Voy a dejar hacer algo inválido.
Dice movimientos inválidos, hace una pausa.
Presiono regresar, obtengo para ir de nuevo jugador 2.
Ahora golpeo uno, vuelve a dibujar con la o en un lugar.
Y continúo esto hasta tenemos un ganador o un perdedor.
Así que hagamos un ganador para eso.
Ahora x va a ser, 2 o es va a ser 5, x va a ser 6
y o va a ser 9.
Se acabó el juego porque acabamos de sacar 3 0.
Entonces lo único que olvidé fue después del ciclo while para mostrar
las felicitaciones que ganó.
Y todo lo que tenemos que hacer es tenemos que comprobar el estado del juego.
Si el estado del juego es igual a uno, eso significa un jugador uno y sería
el último jugador en ganar.
Entonces imprimimos jugador porcentaje d gana.
De lo contrario, vamos para imprimir un dibujo.
Porque si salimos de nuestro bucle y el estado era
negativo, sabemos que el juego había terminado y tuvo un resultado,
es posible que tengamos ese último si declaración para mostrar los resultados.
Así que ahora hagámoslo de nuevo como ganador.
Y ahora realmente ver a alguien ganar.
Así que solo voy a poner válido números aquí, causa
una ganancia rápida para x y realmente tengo que hacerlo en este programa porque ese se va.
Ahí va, el jugador uno gana y tocó otro sonido agradable allí.
Así que esta fue una conferencia larga.
Pido disculpas por la larga conferencia.
Estudie este código, yo proporcione como archivo fuente.
Con suerte, aprenderá mucho sobre métodos en divide y vencerás.
Gracias