Considere uma matriz
de caracteres que representa o tabuleiro de um Jogo da Velha. O caractere
(letra
maiúscula) e o caractere
(letra o maiúscula) são os símbolos utilizados pelos jogadores. Desenvolva um programa que dada uma matriz
preenchida com caracteres X e O imprima na tela o caractere
se o jogador que utilizou este símbolo ganhou o jogo; imprima o caractere
se o jogador que utilizou este símbolo ganhou o jogo; imprima o caractere I se o jogo está incompleto (ainda não houve vencedores); e imprima o caractere E se houve empate no jogo.
Consideração: Os elementos da matriz só podem ser os caracteres X, O e espaço em branco, sendo que o espaço em branco (’ ') indica que não foi feita nenhuma jogada nessa posição.
Passo 1
O que o enunciado pede (em palavras simples): dado um tabuleiro
do Jogo da Velha — isto é, uma matriz com 3 linhas e 3 colunas cujos elementos são os caracteres
,
ou espaço em branco — você precisa decidir qual dos quatro símbolos imprimir:
-
se o jogador que usa venceu; -
se o jogador que usa venceu; -
se o jogo está incompleto (não houve vencedor e ainda existem casas vazias); -
se houve empate (nenhum vencedor e não há casas vazias).
Informações relevantes dadas:
- A entrada é uma matriz
. - Cada posição contém exatamente um dos caracteres
, ou o espaço em branco . - Uma vitória ocorre quando algum símbolo ocupa três posições iguais em linha reta: em qualquer das 3 linhas, em qualquer das 3 colunas, ou em uma das 2 diagonais (principal ou secundária).
(O próximo passo mostra como transformar essas regras em um procedimento passo a passo e como implementá-lo.)
Passo 2
Entendendo as linhas vencedoras (o que procurar).
- Existem exatamente 8 possíveis “linhas” que garantem vitória:
- Linha 1: posições
. - Linha 2: posições
. - Linha 3: posições
. - Coluna 1: posições
. - Coluna 2: posições
. - Coluna 3: posições
. - Diagonal principal: posições
. - Diagonal secundária: posições
.
- Linha 1: posições
Para detectar vitória, basta verificar cada uma dessas 8 linhas e checar se as três entradas são todas iguais a
ou todas iguais a
.
Passo 3
Estratégia passo a passo do algoritmo — esqueleto lógico
- Ler as 3 linhas do tabuleiro e armazenar numa estrutura
tal que é o caractere da linha e coluna , com . - Construir a lista (ou conjunto) das 8 linhas vencedoras; cada linha é uma lista de três coordenadas.
- Inicializar dois indicadores booleanos:
-
- Para cada linha vencedora:
- Ler os três caracteres dessa linha:
. - Se
então . - Se
então .
- Ler os três caracteres dessa linha:
- Contar também se existe pelo menos um espaço em branco no tabuleiro; isto serve para saber se o jogo está incompleto.
- Aplicar a regra de decisão final (detalhada no Passo 4) e imprimir exatamente um dos caracteres
, , ou .
Explicação pedagógica: a ideia é simples — varrer todas as formas possíveis de ter três iguais em linha. Não precisa de matemática avançada, apenas índice e comparação de três caracteres.
Passo 4
Regras de decisão final (por que nessa ordem).
Depois do passo de verificação você tem:
Depois do passo de verificação você tem:
-
(True/False) -
(True/False) -
(True se existe ao menos um caractere , caso contrário False)
Decisão:
- Se
e não então imprimir . - Senão, se
e não então imprimir . - Senão, se nem
nem e então imprimir (incompleto). - Senão (isto é, nem
nem e não há espaços) imprimir (empate).
Observação sobre casos ambíguos: em um tabuleiro arbitrário pode acontecer que ambas as variáveis
e
fiquem True (por exemplo, quando a matriz não representa um jogo válido mas foi construída livremente). O esquema acima trata esse caso caindo no último else (empate), porque as duas condições exclusivas não são satisfeitas. Normalmente problemas de correção de entrada não fornecem matrizes inválidas, mas com essa regra você produz uma resposta definida para qualquer entrada.
Passo 5
Exemplos práticos (para fixar a ideia). Em cada exemplo mostrarei o tabuleiro e a saída esperada.
Exemplo A (vitória de
):
Linha1:
Linha2:
Linha3:
Aqui há a linha toda com
→ resultado:
.
Linha1:
Linha2:
Linha3:
Aqui há a linha
Exemplo B (vitória de
na diagonal):
Linha1:
Linha2:
Linha3:
A diagonal principal não é toda igual, mas a diagonal secundária
é
→ resultado:
.
Linha1:
Linha2:
Linha3:
A diagonal principal
Exemplo C (incompleto):
Linha1:
Linha2:
Linha3:
Não há três iguais numa linha; existe pelo menos um espaço → resultado: .
Linha1:
Linha2:
Linha3:
Não há três iguais numa linha; existe pelo menos um espaço → resultado:
Exemplo D (empate):
Linha1:
Linha2:
Linha3:
Nenhuma linha vencedora e não há espaços → resultado: .
Linha1:
Linha2:
Linha3:
Nenhuma linha vencedora e não há espaços → resultado:
Exemplo E (ambíguo — ambos têm linhas): (entrada inválida como jogo)
Linha1:
Linha2:
Linha3:
Aqui e
. Pelo critério explicado, o algoritmo dará
. Se o avaliador exigir outro comportamento para esse caso, a regra de negócios teria que ser especificada — mas para a maioria dos problemas a entrada não inclui esse caso.
Linha1:
Linha2:
Linha3:
Aqui
Passo 6
Implementação (detalhes práticos que ajudam na prova e na programação).
- Forma simples de representar as 8 linhas: criar uma lista de oito listas de coordenadas.
- Para cada linha, extrair os três caracteres e comparar: isto evita escrever 8 condicionais separadas.
- Se estiver escrevendo em Python, leia cada linha com input() e trate espaços corretamente (aceite tanto linhas do tipo “X O X” quanto “XOX”).
Abaixo, coloquei uma implementação pronta e robusta em Python que aplica exatamente o procedimento explicado. Use-a como base no seu programa ou para colar no seu editor.
Resposta
import sys
def read_board():
board = []
for _ in range(3):
s = sys.stdin.readline()
if not s:
s = ‘’
s = s.rstrip(’\n’)
tokens = s.split()
if len(tokens) == 3:
row = [tokens[0], tokens[1], tokens[2]]
else:
# pega os primeiros 3 caracteres, completando com espaços se necessário
row = list(s)
while len(row) < 3:
row.append(’ ')
row = row[:3]
# normaliza: qualquer caractere que não seja ‘X’ ou ‘O’ vira espaço
row = [c if c == ‘X’ or c == ‘O’ else ’ ’ for c in row]
board.append(row)
return board
board = []
for _ in range(3):
s = sys.stdin.readline()
if not s:
s = ‘’
s = s.rstrip(’\n’)
tokens = s.split()
if len(tokens) == 3:
row = [tokens[0], tokens[1], tokens[2]]
else:
# pega os primeiros 3 caracteres, completando com espaços se necessário
row = list(s)
while len(row) < 3:
row.append(’ ')
row = row[:3]
# normaliza: qualquer caractere que não seja ‘X’ ou ‘O’ vira espaço
row = [c if c == ‘X’ or c == ‘O’ else ’ ’ for c in row]
board.append(row)
return board
def result_for_board(board):
lines = [
[(0,0),(0,1),(0,2)],
[(1,0),(1,1),(1,2)],
[(2,0),(2,1),(2,2)],
[(0,0),(1,0),(2,0)],
[(0,1),(1,1),(2,1)],
[(0,2),(1,2),(2,2)],
[(0,0),(1,1),(2,2)],
[(0,2),(1,1),(2,0)]
]
X_wins = False
O_wins = False
has_space = False
lines = [
[(0,0),(0,1),(0,2)],
[(1,0),(1,1),(1,2)],
[(2,0),(2,1),(2,2)],
[(0,0),(1,0),(2,0)],
[(0,1),(1,1),(2,1)],
[(0,2),(1,2),(2,2)],
[(0,0),(1,1),(2,2)],
[(0,2),(1,1),(2,0)]
]
X_wins = False
O_wins = False
has_space = False
for i in range(3):
for j in range(3):
if board[i][j] == ' ':
has_space = True
for line in lines:
a = board[line[0][0]][line[0][1]]
b = board[line[1][0]][line[1][1]]
c = board[line[2][0]][line[2][1]]
if a == b == c == 'X':
X_wins = True
if a == b == c == 'O':
O_wins = True
if X_wins and not O_wins:
return 'X'
elif O_wins and not X_wins:
return 'O'
elif not X_wins and not O_wins and has_space:
return 'I'
else:
return 'E'
if name == “main”:
board = read_board()
print(result_for_board(board))
board = read_board()
print(result_for_board(board))