Proponha uma correção, faça uma sugestão
Vamos Programar? – Introdução à Programação #23
O mundo está constantemente a evoluir: desde o mais pequeno inseto à espécie Humana. Dentro das palavras que mais ouvimos atualmente, incluímos “evolução”, “mudança”, “futuro”.
A tecnologia tem revolucionado o mundo das mais diversas formas: do mais simples aparelho para medir o tempo ao mais complexo acelerador de partículas. Se quer entrar no mundo da tecnologia e deixar a sua marca, pode começar aqui.
Como referido no início desta sub-saga, isto é apenas uma Introdução à Programação com a linguagem C, daí o primeiro capítulo do Vamos Programar? estar quase concluído. Este capítulo terminará no episódio 25.
Nesta e na próxima semana iremos deixar aqui dois grandes exercícios e o código da sua resolução. Mais abaixo encontra um inquérito para sabermos o que gostava de ver na próxima sub-saga do Vamos Programar?.
Construir o Jogo do Galo
O primeiro desafio final consiste em desenvolver um pequeno Jogo do Galo de linha de comandos. Abaixo encontra as regras do jogo, tal como alguns objetivos/dicas de resolução.
Regras:
- São necessários dois jogadores;
- Existe um tabuleiro 3x3, onde um dos jogadores coloca X e o outro coloca O;
- Um jogador vence quando coloca a sua peça numa linha, coluna ou diagonal inteira.
Objetivos
- O primeiro jogador deverá começar por jogar o "X" e o segundo um "O".
- No final de cada jogo e no início da execução do programa, deve ser perguntado ao jogador se deseja jogar ou sair do programa;
- Tente não utilizar as funções "fflush" e "_fpurge".
Os jogadores deverão fornecer o número da linha e da coluna em que querem colocar as peças. Pode consultar a proposta de resolução aqui.
Mais uma vez, gostávamos de saber a sua opinião. Caso tenha alguma dúvida, pode sempre utilizar os comentários para colocar a questão. Caso o faça, pedimos que utilize a keyword [DUVIDA] no início do seu comentários.
| Resoluções de exercícios. |
Esta saga |
Henrique Dias |
| Mais episódios: [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13][12] [14] [15] [16] [17] [18] [19] [20] [21] [22] [23][24] |
|
Este artigo tem mais de um ano
Loading ...
Como assim está no fim?? Não vão falar de ficheiros? leitura de ficheiros??
#1 percebo o que queres dizer, mas tens de ver que é uma introdução
Não se esqueça que isto é apenas uma introdução cujo objetivo é dar uma boa visão acerca dos comandos e primitivas da maioria das Linguagens de Programação. 🙂
Eu compreendo que é uma introdução mas acho que ficamos muito à quem dos esperado. Eu aprendi C com um livro porque na Internet a informação está muito dispersa e qualquer pessoa perde-se com muita facilidade.
Era apenas isso, nada mais
Boa noite Jorge,
Eu também o estou a compreender. Esta saga também será condensada num “mini-livro” em pdf, revista por um colega nosso e publicada no último artigo 🙂
Na próxima linguagem, abordaremos mais. Já votou?
Jogo do Galo… Foi a minha primeira “brincadeira” assim que ganhei uma luzes de programação, na altura em Pascal! Tinha som e tudo! Se não falha a memória 1994!
Segue meu PORCO-CODE
#include
void mostra_galo(void);
int jogada_valida(int jlinha, int jcoluna);
void registra_jogada(int jlinha, int jcoluna, int jjogador);
int verifica_vencedor(void);
int jogadas, jogador, linha, coluna, vencedor;
char galo[3][3];
char jogador1[15], jogador2[15];
int main(void) {
printf(“Galo !\n\n”);
memset(galo, ‘ ‘, 9);
jogadas = 0;
jogador = 1;
vencedor = 0;
printf(“Entre com o nome do Jogador 1: “);
scanf(“%14s”, &jogador1);
printf(“Entre com o nome do Jogador 2: “);
scanf(“%14s”, &jogador2);
mostra_galo();
while(vencedor == 0) {
if(jogador == 1) printf(“%s, entre linha e coluna (linha,coluna): “, jogador1);
if(jogador == 2) printf(“%s, entre linha e coluna (linha,coluna): “, jogador2);
scanf(“%1d,%1d”, &linha, &coluna);
if(jogada_valida(linha, coluna)) {
jogadas++;
registra_jogada(linha, coluna, jogador);
mostra_galo();
if(jogador == 1) jogador = 2; else jogador = 1;
}
else printf(“Jogada inválida! Tente novamente.\n\n”);
vencedor = verifica_vencedor();
}
printf(“Temos um vencedor! Parabéns “);
if(vencedor == 1) printf(“%s”, jogador1);
if(vencedor == 2) printf(“%s”, jogador2);
printf(“! Vocé é o Vencedor!\n\n”);
}
void mostra_galo(void) {
printf(“\nJogador 1: %s | Jogador 2: %s | Numero de Jogadas: %d\n\n”, jogador1, jogador2, jogadas);
printf(” COLUNA \n”);
printf(” 1 2 3 \n”);
printf(” |—|—|—|\n”);
printf(“L 1 | %c | %c | %c |\n”, galo[0][0], galo[0][1], galo[0][2]);
printf(“I |—|—|—|\n”);
printf(“N 2 | %c | %c | %c |\n”, galo[1][0], galo[1][1], galo[1][2]);
printf(“H |—|—|—|\n”);
printf(“A 3 | %c | %c | %c |\n”, galo[2][0], galo[2][1], galo[2][2]);
printf(” |—|—|—|\n\n”);
return;
}
int jogada_valida(int jlinha, int jcoluna) {
if((jlinha > 3) || (jcoluna > 3)) return 0;
if(galo[jlinha – 1][jcoluna – 1] != ‘ ‘) return 0;
return 1;
}
void registra_jogada(int jlinha, int jcoluna, int jjogador) {
if(jjogador == 1) galo[jlinha – 1][jcoluna – 1] = ‘X’;
if(jjogador == 2) galo[jlinha – 1][jcoluna – 1] = ‘O’;
return;
}
int verifica_vencedor(void) {
int n;
for(n = 0; n < 3; n++) {
if((galo[n][2] == galo[n][1]) && (galo[n][1] == galo[n][0])) {
if(galo[n][0] == 'X') return 1;
if(galo[n][0] == 'O') return 2;
}
if((galo[2][n] == galo[1][n]) && (galo[1][n] == galo[0][n])) {
if(galo[0][n] == 'X') return 1;
if(galo[0][n] == 'O') return 2;
}
}
if((galo[0][0] == galo[1][1]) && (galo[1][1] == galo[2][2])) {
if(galo[1][1] == 'X') return 1;
if(galo[1][1] == 'O') return 2;
}
if((galo[0][2] == galo[1][1]) && (galo[1][1] == galo[2][0])) {
if(galo[1][1] == 'X') return 1;
if(galo[1][1] == 'O') return 2;
}
return 0;
}
jogador = (jogador == 1) ? 2 : 1
Sim, essa linha de código é equivalente a:
if (jogador == 1)
jogador = 2;
else
jogador = 1;
Uma outra forma interessante para trocar de jogador (neste caso específico) seria:
jogador ^= 0x03;
Cumps!
Agora perdi-me!
Qual a diferença entre usar ^= e &= ?
& -> AND
^ -> XOR
Quando usas AND, o resultado vai ter os bits a ‘1’ quando ambos os bits na mesma posição está a ‘1’ nos operandos.
Quando usas XOR, o resultado vai ter os bits a ‘1’ quando os bits na mesma posição dos operandos diferem.
Exemplo:
1 & 3 = 1
2 & 3 = 2
3 & 3 = 3
1 ^ 3 = 2
2 ^ 3 = 1
3 ^ 3 = 0
A operação XOR é utilizada quando queres fazer “bit flipping”. Isto é, se tens uma variável e queres alterar o 3º bit para o valor oposto, fazes:
var ^= 0x04; // 0x04 = 00000100
Interessante, nunca tinha pensado nesse uso. Obrigado!
Olá Henrique. Queria apenas congratular pelo excelente trabalho nesta saga, e dizer que vou guardar a solução fornecida como “boas práticas em C”. Cumprimentos.
Jogo do Galo feito, testem e digam algo! Desde ja otima iniciativa 🙂 ppl
Segue a baixo o link do projeto:
https://www.dropbox.com/s/vxueoe6qyynt24b/GaloGame.zip?dl=0
Cumpz
Eu tenho este código como consigo fazer o jogo do galo?
#include
#include
#include
#define LINHAS 3
#define COLUNAS 3
char matrix[COLUNAS][LINHAS];
void delay(unsigned int mseconds){
clock_t goal=mseconds+clock();
while(goal>clock());
}
void InitMatrix(void){
char i,j;
for(i=0;i<LINHAS;++i){
for(j=0;j<COLUNAS;++j){
matrix[i][j]=0;
}
}
}
void printMatrix(void){
char i,j;
for(i=0;i<LINHAS;++i){
for(j=0;j<COLUNAS;++j){
printf(" %d ",matrix[j][i]);
if(j<(COLUNAS-1)) printf("|");
}
printf("\n");
if(i<(LINHAS-1)){
for(j=0;j<COLUNAS;++j){
if(j “);
scanf(“%d”,&jogada);
printf(“Jogaste %d”,jogada);
}