Olá e bem-vindo.
Eu gostaria de fornecer uma solução para o desafio do jogo da velha.
Agora lembre-se, há muitos soluções para um determinado problema.
Esta só vai ser a minha solução.
Se sua solução for diferente contanto que você siga as
boas práticas de programação e use a linguagem de programação c da
maneira correta, então tudo bem.
Estou apenas fornecendo minha solução.
Tenho certeza que pode ser melhorado.
Então vamos começar.
Vou criar um novo projeto é chamado de jogo da velha
obviamente, e nós vamos comece a tentar modulá-lo.
Eu tentei quebrar como eu fiz na descrição da palestra.
Vou criar um apenas alguns módulos ou devo
dizer algumas funções.
Esperançosamente, este será ok e funcionar bem para você.
Estou usando a caixa de camelo para todos os meus nomes convenções exatamente o que estou acostumado.
Nós poderíamos até mesmo separar isso em vários arquivos de origem
também, se quisermos.
Portanto, temos o nosso principal.
Vamos nos livrar deste printf.
Vou incluir um incluir adicional.
Isso me permitirá basicamente limpar o nosso sistema e algumas coisas
boas, permitir eu também acho que remover um char.
Então, além desses 2 bibliotecas, vamos incluir conio. h.
E o que eu quero fazer e eu deseja atacar este problema.
Eu quero tentar modular Tanto quanto eu puder.
Eu mencionei que vou para usar uma
única matriz dimensional, uma matriz bidimensional pode até funcionar melhor.
Mas vou implementar isso usando uma única
matriz dimensional que representa nosso jogo bordo, nosso jogo da velha.
Vou criar este como uma variável global.
Estou usando uma variável global aqui porque
eu não demonstrei o conceito de passagem de dados por referência em c.
Eu não quero te confundir.
Eu não teria que usar global dados aqui
e eu poderia passar os dados para funções, mas gostaria precisa usar passagem por referência.
Eu teria que passar por aí ponteiros, e não
discutimos nada disso ainda.
Vou usar dados globais.
Perdoe-me, memorize que os dados globais são geralmente não
é uma coisa boa a se fazer, mas porque, novamente, estamos tentando demonstrar aprendizado, dividir
conquistar e estamos tentando demonstrar como usar funções, preciso usar dados globais
porque nós não falei sobre dicas ainda.
Então, meus dados globais aqui que vou usar é meu quadrado que representa
minha grade, meu jogo da velha.
Este vai ser um único área dimensional de
10 elementos, principalmente porque eu não deseja usar o elemento 0.
Vou usar este array para escolha os números para jogar.
Também vai permitir para ter minhas coordenadas.
Vou inicializar isso com apenas valores de 1 a 9.
E isso vai ser um matriz de caracteres porque eu preciso
colocar os xe os nele.
Nós não falamos sobre personagem matrizes ainda, mas isso me permitirá
colocar caracteres únicos.
É como o conceito de array de ints, exceto que contém caracteres.
Personagens, lembre-se, têm aspas simples em torno deles.
Então, um 2 3 9 o, 0 aí o o eu só vou
pular, não vou nem usar, porque eu quero usar aqueles.
Isso torna a programação um pouco mais fácil.
Posso usar o valor que o usuário entra como um índice, como um índice válido.
Eu também vou ter que crie 2 variáveis globais para escolha
na vez do jogador.
Então a escolha vai ser o que eles inserido através do teclado, de um a
9, dependendo de onde eles querem colocar seu x ou o.
O jogador vai apenas representa a vez de quem
é o jogador, o jogador um ou o jogador 2.
Não preciso de nenhum outro dado global.
Eu só preciso da minha função declarações aqui.
Eu vou começar com a criação de 3 funções.
Vou ter 3 declarações de função.
Eu vou ter um para verificar se há uma vitória.
Não vai levar nenhum dado.
Ele vai retornar um int.
Vou ter um que não retorna qualquer dado que,
apenas exibe o quadro com os caracteres corretos
Ele também não leva nenhum dado.
E também terei um função que apenas marca o quadro.
Isso levará a entrada do usuário.
E dependendo do que eles inseriram, ele colocará um x ou o no local correto
na matriz e, em seguida, exibirá essa matriz usando placa de exibição.
Então aqui vamos apenas dizer marque a placa e isso vai realmente levar
uma marca com um x ou o.
Então, posso reutilizar isso.
Eu posso reutilizar isso para jogador um ou jogador 2.
3 declarações de função para que eu possa coloque minhas funções em qualquer lugar
do programa, eu as declarei no topo.
E você notará que os 2 destes funções não estão retornando nenhum dado
e apenas uma está tomando um parâmetro.
Vamos implementar essas funções antes de implementar o jogo.
Então, primeiro vamos implemente a verificação para ganhar.
Esta função basicamente vai trabalhe onde vai verificar o quadro para ver
se há alguma vitória.
Então, vai conter muitas declarações if.
Eu provavelmente poderia melhorar este código um pouco.
Mas vou colocar alguns comentários aqui porque devemos sempre ter
comentários no topo de nossa função.
Eles são bastante simplificados.
Devemos ter o nome da função.
Isso basicamente quer dizer que a função irá
retornar um status de jogo de um se o jogo acabou, diga se você ganhou,
um resultado negativo se o o jogo está em andamento e 0 se o jogo
acabou e houve um empate.
Portanto, esta função verifica um está retornando um int.
Então eu vou em frente e definir isso.
E tudo o que isso vai fazer é vai olhar
para a matriz e ver se há algum ponto lá, se 3x for correspondido.
Portanto, há muito diferentes instruções if.
Então, como sabemos se um jogador é um.
Bem, sabemos se um jogador é um se eles corresponderem em uma linha diagonal
ou em uma coluna.
Portanto, temos que verificar cada uma dessas situações.
E conhecemos as linhas no colunas com base na matriz.
Então, se meu quadrado um é igual ao quadrado 2 e
quadrado 2 é igual ao quadrado 3, o que significa que nós tem uma correspondência em nossa primeira linha.
Então eu também vou crie um valor de retorno aqui.
No topo, vou apenas dizer valor de retorno, inicialize-o com 0.
Vamos inicializar isso para 0 para final de jogo.
E se tivermos uma partida em a primeira linha,
vou devolver um, o jogo acabou.
Então, temos que ter uma série de outros ifs para corresponder e, na verdade, eu não
quero retornar um que eu quero definir meu valor de retorno.
Porque poderíamos voltar, mas isso torna o programa mais difícil de seguir.
Caso contrário, nós vamos verifique todas as nossas outras linhas.
Vou copiar e colar algum código aqui porque
é muito código redundante.
A única coisa que é interessante é se tivermos um empate.
Então, deixe-me colocar em todos os mais ifs para vencedores.
E então eu também vou retornar valores diferentes.
Em vez de ter um monte de outras ifs, eu poderia ter e comercial, mas
isso é ainda mais difícil de ler.
Então, se tivermos uma partida na primeira linha.
E vamos ter certeza de que nosso recuo está correto.
Se tivermos uma correspondência em nossa segunda linha, é isso que o segundo está fazendo.
Se tivermos uma correspondência em nossa terceira linha, retornar um adicionar algumas novas linhas para facilitar a
leitura, não precisa de nenhum colchete porque são declarações únicas.
Na linha 37, parece que estamos combinando um, 4 e 7.
Então, isso parece um correspondência diagonal, retorna um.
Quarenta, estamos combinando 2 5 e 8.
Isso parece uma combinação do centro indo para baixo, então a segunda coluna.
3 6, você pode ver o outros jogos também.
Temos que basicamente pegar todas as partidas para linhas, colunas e diagonais.
E é isso que fizemos com todos essas declarações olhando na matriz.
Agora, a única coisa que nos diz se nós não temos uma partida ou temos um empate é
que temos que comparar todos eles e basicamente, certifique-se de que não sejam os
números que foram inicializados.
Então, se tivermos nosso quadrado de matriz e não contém 1 2 3 1 2 3 4 5 6
8 ou 9 para qualquer um dos valores, isso significa que temos um empate porque eles contêm
um 0 ou um x.
Podemos escrever outro se isso basicamente diz
que é um empate e podemos definir o valor de retorno para 0, valor de retorno igual a 0.
E, novamente, isso é basicamente verificar este último senão se, se os
números forem iguais à medida que foram inicializados.
Se eles são todos diferentes, então isso significa que podemos retornar 0.
Vamos colocar esse.
Caso contrário, se não tivermos um empate e não temos um vencedor,
isso significa que não terminamos.
Portanto, uma declaração final do else pode apenas dizer o valor de retorno é igual a um negativo.
Porque lembre-se, a função é retornar um negativo para o
jogo em andamento um para o fim do jogo e 0 para jogo sem resultado.
E então a última coisa que eu quero fazer é eu quero retornar o valor de retorno.
Então aqui estou indo para diga retorno, valor de retorno.
E isso irá completar a função.
E o que você nota quando estamos fazendo isso,
estamos dividindo e conquistando.
Todos nós estamos focando certo agora está verificando o tabuleiro para ver se
há uma vitória.
Iríamos trabalhar em pequenos pedaços assim e nós
testaríamos constantemente.
Isso nos permite focar em nosso design e também nos permite reduzir ou isolar
nossos erros mais facilmente.
Agora que terminamos com o tabuleiro de jogo, queremos ir em frente
e implementar o painel de exibição.
A placa de exibição é apenas vai mostrar a placa.
Então, tudo o que isso realmente precisa fazer é desenhe a matriz em um formato específico.
Então, vamos escrever um função chamada placa de exibição.
Não vai retornar nenhum dado, não vai ter nenhum parâmetro.
A razão pela qual é um número de
função uma é porque vamos precisar desenhar o tabuleiro muitas vezes e também é melhor
porque está realizando uma tarefa específica.
Agora, este só vai ter um monte de funções de printf nele.
E vai ter um monte de formatação.
Vou copiar e colar.
O que é único aqui é Estou limpando a tela todas as vezes.
Mas se você disser sistema e windows e você diz cls, isso vai
limpar a tela.
Isso apenas o torna mais limpo.
Então vamos apenas fazer um monte de printfs.
Vamos imprimir o título do jogo. Vamos imprimir os jogadores 1 e 0.
E então nós vamos para imprimir o quadro.
A placa vai ficar bem formatado com algumas barras paralelas
e, em seguida, imprimiremos o valores de todos os valores na matriz.
E se o valor for x ou 0, ele será exibido.
Se não for, exibirá um número para que possamos usar esse número para
selecionar nossa opção de sorteio e isso é isso, é tudo o que essa função faz.
Agora que terminamos com exibindo o quadro,
agora queremos criar nossa última função que está marcando o tabuleiro.
Portanto, a placa de marcação vai definir a matriz com um valor
específico, e ela vai digitar uma marca em um x ou um o.
Então, vai precisar de um personagem.
O que isso vai fazer é terá um
monte de outras instruções if if.
Então, aqui em nosso quadro de
marcação, estamos vou querer basicamente dar alguns comentários e dizer que este vai
definir o tabuleiro com o caractere correto x ou o no local correto na matriz.
Espero que faça sentido.
Como você vê o código eu tenho que terminar meus comentários.
Eu quero formatar isso legal então são 2 linhas aqui.
E tudo isso vai fazer
vai verificar o que o usuário digitou.
Então lembre-se, temos 2 dados globais valores para os quais o usuário inseriu.
Nós também temos um valor para o jogador atual.
Então a escolha vai ser basicamente o que é inserido por meio do teclado.
Ainda não implementamos isso porque vamos implementar isso
na função principal.
O jogador vai ser o jogador atual.
Vamos precisar de ambos destes para deixar nossas marcas.
Então o que vamos fazer é vai ter um monte
de instruções else, instruções if else.
Vamos verificar a escolha, que é a entrada do usuário.
E se a escolha for igual a 1, nós quero desenhar algo nesse quadrado.
Também queremos ter certeza que esse quadrado está disponível.
Então, se for igual a 1 e não for atualmente igual a 1, isso
significa que basicamente alguém já colocou um x ou um o lá e não podemos usá-lo.
Se for igual a um e eles entrou um, isso significa que podemos definir
o array para um valor específico.
Vamos definir a matriz para o que foi passado em o o x.
E vamos repetir para fazer isso para cada escolha.
Se forem as opções 2 3 4 5 6 8 ou 9.
Então, um monte de outros ifs que fazem a mesma coisa.
Se o usuário inseriu a opção 2, estamos vamos ter certeza de que
o recuo está bom e o quadrado 2 está disponível, vamos marcar o quadrado 2 com tudo o
que passamos aqui.
E dependendo de qual jogador é a vez é, vamos passar um ou um x.
Agora, a última coisa que precisamos fazer em esta função é que temos que validar.
Se eles passaram em alguma coisa diferente de um a 9,
esse movimento é inválido.
Então, nossa última declaração aqui irá imprimir uma mensagem dizendo movimento inválido, marque o jogador
abaixo um.
Porque lembre-se de jogadores são um ou 2.
E vamos marcar o jogador de volta e então vamos incrementá-lo em
nosso loop em nossa função principal.
E então esta última coisa char está apenas pausando o programa para
que o usuário tenha que clicar retornar após movimento inválido.
Caso contrário, o movimento inválido seria ser exibido e, em seguida,
seria imediatamente apagado porque nós redesenharíamos o tabuleiro novamente.
Então get char faz uma pausa.
Força você a apertar o botão Enter para prosseguir e inserir outro valor.
E essas são nossas 3 funções.
Lembre-se, esta função não retorna nada.
Portanto, podemos mantê-lo no fundo.
Agora temos que realmente implementar o jogo.
O jogo continua na função principal.
Então, para o jogo, é aqui que vamos pedir ao usuário para inserir um
número, vamos desenhar o bordo, vamos verificar se há vitória.
Então, vamos criar 2 variáveis locais aqui, e
vamos inicializar nosso player.
Aqui nós vamos crie nosso inteiro I.
Isso será usado em nosso loop.
E nossa marca vai ser x ou o, dependendo de quem é a vez.
Mark vai ser x ou o, eu acredito.
Mark vai ser x ou o.
E a escolha vai ser o que o usuário entra através do teclado.
Portanto, 2 variáveis locais.
Também vamos definir nosso jogador, que é uma variável global.
Inicialmente, só vai seja o jogador um para começar o jogo.
Então teremos um loop.
Teremos basicamente um loop até terminarmos de jogar.
Vou usar um tempo loop aqui porque eu quero que ele
seja executado pelo menos uma vez.
Eu quero mostrar o embarcar pelo menos uma vez.
Vou mostrar o tabuleiro e jogo
até conseguir basicamente um empate ou uma vitória.
Então eu vou fazer isso, contanto que como I é é igual a 1 negativo.
O que um 1 negativo representa, representa que o jogo está em andamento.
Eu vou ser o retorno valor para verificar a vitória.
E você verá que em um segundo, mas basicamente
quando eu tenho um loop que continua fazendo a mesma coisa e termina até que o jogo termine.
E o jogo vai ser sobre se não for negativo.
Então, o que temos que fazer primeiro.
A primeira coisa que temos que fazer é temos que mostrar o quadro.
Então, posso apenas ligar para o placa de exibição de funções.
Então temos que calcular o jogador.
E o jogador começa com o jogador um.
O que vamos fazer
aqui é vamos usar um operador ternário, e vamos dizer se o jogador mod 2, então
o jogador é igual a 1, senão é igual a 2.
Esta é uma maneira de determinar o jogador certo.
Cada iteração do loop está acontecendo para mudar de um para 2 ou 2 para um.
Quando começa como jogador um, vai dizer jogador mod 2,
um dividido por 2 ou o resto de um dividido por 2 é o que, um.
Então, se for um, você é vai ser o jogador um.
E quando você voltar para o próxima iteração,
o jogador será igual a 2 porque vamos incrementá-lo.
2 mod 2 é 0.
Então, se não for igual a um, então o jogador será
igual ao jogador 2.
Só vai configurá-lo para jogador um se o jogador mod 2 for um.
Lembre-se, aquele torneiro operador, esperançosamente.
A próxima coisa que eu preciso fazer é precisa obter a entrada do usuário.
Então aqui vou dizer, vou para pedir ao usuário para inserir um número.
Vou dizer jogador por cento d jogador 1 ou 2, digite um número, e então colocarei o jogador
para imprimir, jogador um ou 2.
Então vou ler o entrada do usuário usando scanf.
E isso vai ser um número inteiro, isso vai representar um
ponto no tabuleiro de um a 9.
E eu vou armazenar isso na minha variável de escolha.
A escolha é uma polegada, então eu tem que passar no endereço, e
eu tenho que dizer escolha.
Só se for uma corda eu iria não passe o endereço.
Então posso basicamente determinar seja ou não qual é a marca.
Eu tenho que determinar se a marca é um x ou não com base no player.
Vou usar o operador ternário novamente.
E vou atribuir para marcar um x ou o.
Se o jogador for igual a 1, vou para atribuir para marcar o x, x maiúsculo.
Caso contrário, eu vou atribua-lhe um o, o maiúsculo.
Portanto, este operador ternário é muito útil quando você precisa atribuir
variáveis com base em uma condição.
Novamente, o que isso está dizendo é se o jogador for igual a
1, marca vai ser igual a x.
Caso contrário, será igual a o.
O ponto de interrogação representa se a avaliação booleana é verdadeira, os dois
pontos representam se ela é falsa.
Agora que recebi a letra correta, Posso chamar
minha função para marcar o tabuleiro apenas dizendo marcar placa, passando em x ou o.
Depois de marcar o quadro e eles feita a seleção,
tenho que verificar se tem um vencedor.
Eu tenho minha variável que realmente deveria
provavelmente deveria ser um nome melhor.
Vamos chamá-lo de verificação de status, jogo verifique como sobre isso ou o status do jogo.
E o status do jogo vai ser igual a um um negativo ou 0.
O status do jogo vai para ser igual a tudo o que é
retornado de cheque para ganhar
Porque lembre-se, esta função irá retorna um um 0 ou um negativo.
Um se o jogo acabar com o resultado, negativo se o jogo estiver em andamento, 0
se acabou sem resultado.
Agora que armazenamos o jogo status, também queremos alterar
a condição do loop.
Então, se o status do jogo for igual a um
negativo, sairemos do loop.
Caso contrário, tudo o que precisamos fazer é mudar a vez do jogador.
Como mudamos a vez do jogador, nós apenas incrementamos o jogador em um.
Assim da próxima vez ele vai subir e será 2, e o jogador será
igual a 2 e vamos voltar para baixo.
Quando eles fazem tentativas inválidas, o que acontece nos modelos inválidos, ele
diminui a contagem de jogadores.
Quando você diminui a contagem de jogadores, você volta para o jogador correto.
Então, se for um, você diminui para 0, a próxima curva será uma, é
essencialmente a mesma curva novamente.
É por isso que o incrementamos.
Agora, se for o jogador 2, nós o incrementamos em um.
E o que acontece é 2 dividido 2 é 0.
Então, realmente define o jogador de volta a um.
É assim que funciona.
Mas essa é toda a lógica.
Fizemos muito aqui.
Você não deve escrever tudo este código e teste de uma vez.
Você deveria estar trabalhando com dividir para conquistar, testando constantemente
enquanto executa o código.
Agora vou fornecer esta solução, mas vamos executá-la
e testá-la.
Vai funcionar exatamente como funcionou em a demonstração da palestra de desafio.
Mas, novamente, estude este código e faça certeza de que você entende o que está acontecendo.
O uso de matrizes e a divisão abordagem de conquista, mas veja como
esse método principal parece bom.
É muito fácil saber o que é acontecendo no método principal.
Exibir quadro, trocar de jogador e você provavelmente deseja colocar comentários aqui.
Mude as curvas, e então também aqui obter informações.
E então defina o correto letra, defina o personagem correto com
base no turno do jogador.
Você nem mesmo precisa esses comentários porque
as funções são muito descritivas.
Marque a placa, defina a placa com base em a escolha do usuário ou escolha inválida.
E então a verificação de status do jogo para ganhar, bastante autoexplicativo.
E então nós saltamos se o jogo acabou.
Vamos construir isso.
Esperançosamente, não receba erros, não avisos, nós não, o que é bom.
Agora vamos executá-lo e você vai veja que funciona exatamente como na nossa demonstração.
A primeira coisa que faz é vai exibir a tela.
E vai permitir para imprimirmos um enter.
E tem nossa grade, uma 2 3 4 5 6 7 8 9 nossa matriz.
Então me diz jogador um insira algo e eu
estou inserindo algo válido.
E ele o desenha, e ele limpa a tela.
Então, parece bom.
E agora existe um x em 3.
Agora é a vez do jogador 2.
Vou deixar fazer algo inválido.
Diz movimentos inválidos, faz uma pausa.
Eu clico em retornar, eu pego para ir de novo jogador 2.
Agora eu acerto um, redesenha com o em um ponto.
E eu continuo isso até temos um vencedor ou um perdedor.
Então, vamos criar um vencedor para nós.
Agora x vai ser, 2 o é vai ser 5, x vai ser 6
e o vai ser 9.
Fim do jogo porque acabamos de desenhar 3 0s.
Então, a única coisa que esqueci foi após o loop while para exibir
os parabéns que você ganhou.
E tudo o que temos que fazer é temos que verificar o status do jogo.
Se o status do jogo for igual a um, isso significa um jogador um e seria
o último jogador a ganhar.
Então, imprimiríamos jogador por cento d vitórias.
Caso contrário, nós vamos para imprimir um desenho.
Porque se sairmos do nosso ciclo e o status
era negativo, sabemos que o jogo acabou e teve um resultado,
talvez tenhamos que ter esse último se declaração para exibir os resultados.
Portanto, agora vamos executá-lo novamente como vencedor.
E agora vamos realmente ver alguém ganhar.
Então, vou apenas colocar números aqui, causa uma vitória
rápida para x e realmente tem que fazer isso neste programa porque aquele vai embora.
Lá vai, o jogador um vence e tocou outro bom som ali.
Portanto, esta foi uma longa palestra.
Peço desculpas pela longa palestra.
Estude este código, vou forneça-o como um arquivo de origem.
Felizmente, aprenda muito sobre métodos em dividir e conquistar.
obrigada