MAC115 Introdução à Computação

Zeroézimo Exercício Programa

(copiado da página web do Prof. Arnaldo Mandel)

VERIFICADOR DE JOGO DA VELHA

O objetivo deste primeiro exercício-programa é familiarizar os alunos com o ambiente de edição, compilação e entrega de trabalhos. Ele não vale nota, mas é bom fazer, pelo seguinte:

• Fazendo, você terá confiança de que instalou o compilador C no seu sistema e está conseguindo usar.
• O eDisciplinas tem suas peculiaridades. Entregando esse EP, você terá confiança de que sabe lidar com a burocracia do site.
• Tem o desafio de escrever um programa com enunciado um pouco mais complicado do que os exercícios feitos em aula.

Introdução

    Neste exercício-programa, vocês irão implementar um programa que verifica um tabuleiro de jogo-da-velha e informa se alguém ganhou, se houve empate, ou se o jogo ainda não terminou.

    Todos vocês estão familiarizados com as regras do dificílimo jogo da velha. Nesse jogo temos dois jogadores, o jogador X (xis) e o jogador O (bola), além de um tabuleiro com três linhas e três colunas, onde cada um dos jogadores pode deixar a sua marca.

           COLUNAS

        1     2     3  
L
I  1    X  |     |  O
N     -----+-----+-----
H  2    0  |  0  |  X
A     -----+-----+-----
S  3    X  |  X  |  

    Na configuração acima, vemos que o jogador X colocou as suas marcas nas posições (1,1), (2,3), (3,1) e (3,2), enquanto o jogador O colocou as suas marcas nas posições (1,3), (2,1) e (2,2). Já as posições (1,2) e (3,3) não foram ocupadas por nenhum jogador e ainda estão vazias.

Tarefa

    Neste exercício-programa você deverá escrever um programa em C que, dada uma configuração de um tabuleiro de jogo da velha, decide se

• o jogador X ganhou a partida;
• o jogador O ganhou a partida;
• houve empate; ou
• a partida ainda nao terminou.

    Uma partida é considerada como empatada se o tabuleiro está totalmente preenchido, mas nenhum jogador ganhou. Caso não haja um jogador vitorioso e algumas posições ainda estejam vazias, considera-se que a partida ainda não terminou.

    A entrada do seu programa serão 9 números inteiros, representando os conteúdos de cada uma das posições de um tabuleiro de jogo da velha. Cada um dos números inteiros pode ser:

• 0: indicando que a posição está vazia;
  
• 1: indicando que há um X na posição; ou
  
• 2: indica que há um O na posição.
  

    O seu programa deve pedir ao usuário que digite os números correspondente aos conteúdos das posições (1,1), (1,2), (1,3), (2,1), (2,2), (2,3), (3,1), (3,2) e (3,3), nesta ordem. Nenhum outro valor deve ser lido pelo seu programa.

    O seu programa deverá analisar a configuração do tabuleiro e imprimir:

• a configuração do tabuleiro lido; e
• uma mensagem dizendo se o jogador X ganhou, ou se o jogador O ganhou, ou se houve empate ou se a partida ainda não terminou.
  

Exemplos de execuções do programa

    Considere os seguintes exemplos de possíveis execuções de seu programa. Os números em vermelho foram digitados pelo usuário.

Exemplo 1

Bem-vindo ao verificador de jogo-da-velha!
Digite os valores das nove posições do tabuleiro (0=vazio, 1=X, 2=O):

(1,1) = 1
(1,2) = 2
(1,3) = 1
(2,1) = 1
(2,2) = 2
(2,3) = 2
(3,1) = 2
(3,2) = 1
(3,3) = 2


  1  |  2  |  1
-----+-----+-----
  1  |  2  |  2
-----+-----+-----
  2  |  1  |  2

Empatou!!!

Exemplo 2

Bem-vindo ao verificador de jogo-da-velha!
Digite os valores das nove posições do tabuleiro (0=vazio, 1=X, 2=O):

(1,1) = 0
(1,2) = 1
(1,3) = 2
(2,1) = 1
(2,2) = 2
(2,3) = 0
(3,1) = 2
(3,2) = 1
(3,3) = 0

  0  |  1  |  2
-----+-----+-----
  1  |  2  |  0
-----+-----+-----
  2  |  1  |  0

O ganhou!!!

Exemplo 3

Bem-vindo ao verificador de jogo-da-velha!

Digite os valores das nove posições do tabuleiro (0=vazio, 1=X, 2=O):

(1,1) = 1
(1,2) = 1
(1,3) = 1
(2,1) = 2
(2,2) = 0
(2,3) = 2
(3,1) = 0
(3,2) = 2
(3,3) = 0

  1  |  1  |  1
-----+-----+-----
  2  |  0  |  2
-----+-----+-----
  0  |  2  |  0

X ganhou!!!

Exemplo 4

Bem-vindo ao verificador de jogo-da-velha!
Digite os valores das nove posições do tabuleiro (0=vazio, 1=X, 2=O):

(1,1) = 0
(1,2) = 1
(1,3) = 0
(2,1) = 2
(2,2) = 0
(2,3) = 0
(3,1) = 1
(3,2) = 0
(3,3) = 0

  0  |  1  |  0
-----+-----+-----
  2  |  0  |  0
-----+-----+-----
  1  |  0  |  0

O jogo não terminou!

Executável

    Construímos um exemplo desse programa, que já está compilado, pronto para rodar. Você pode baixar esse programa, conforme apropriado para o seu sistema:

• ep0 para linux
• ep0.exe para windows

Consistência dos dados

    O seu programa não precisa fazer consistência dos dados de entrada. Isto significa que se, por exemplo, um número negativo for digitado como entrada para o programa, ou uma letra, um cifrão, uma arroba, . . , o seu programa pode travar o computador ou explodir sem ficar envergonhado. Inclusive, o seu programa não deve ser preocupar se a configuração fornecida é válida. Por exemplo, uma configuração em que há 5 marcas X no tabuleiro e nenhum marca O não é válida:

    X  |     |  X
  -----+-----+-----
       |     |  X
  -----+-----+-----
    X  |  X  |