Considere uma matriz 3 \times 3 de caracteres que representa o tabuleiro de um Jogo da Velha. O caractere \mathbf{X} (letra \mathbf{x} maiúscula) e o caractere \mathbf{O} (letra o maiúscula) são os símbolos utilizados pelos jogadores. Desenvolva um programa que dada uma matriz 3 \times 3 preenchida com caracteres X e O imprima na tela o caractere \mathbf{X} se o jogador que utilizou este símbolo ganhou o jogo; imprima o caractere \mathbf{O} 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 3\times 3 do Jogo da Velha — isto é, uma matriz com 3 linhas e 3 colunas cujos elementos são os caracteres X, O ou espaço em branco — você precisa decidir qual dos quatro símbolos imprimir:
  • X se o jogador que usa X venceu;
  • O se o jogador que usa O venceu;
  • I se o jogo está incompleto (não houve vencedor e ainda existem casas vazias);
  • E se houve empate (nenhum vencedor e não há casas vazias).
Informações relevantes dadas:
  • A entrada é uma matriz 3\times 3.
  • Cada posição contém exatamente um dos caracteres X, O ou o espaço em branco \text{ ' ' }.
  • 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:
    1. Linha 1: posições (0,0),(0,1),(0,2).
    2. Linha 2: posições (1,0),(1,1),(1,2).
    3. Linha 3: posições (2,0),(2,1),(2,2).
    4. Coluna 1: posições (0,0),(1,0),(2,0).
    5. Coluna 2: posições (0,1),(1,1),(2,1).
    6. Coluna 3: posições (0,2),(1,2),(2,2).
    7. Diagonal principal: posições (0,0),(1,1),(2,2).
    8. Diagonal secundária: posições (0,2),(1,1),(2,0).
Para detectar vitória, basta verificar cada uma dessas 8 linhas e checar se as três entradas são todas iguais a X ou todas iguais a O.

Passo 3

Estratégia passo a passo do algoritmo — esqueleto lógico
  1. Ler as 3 linhas do tabuleiro e armazenar numa estrutura board tal que board[i][j] é o caractere da linha i e coluna j, com i,j\in\{0,1,2\}.
  2. Construir a lista (ou conjunto) das 8 linhas vencedoras; cada linha é uma lista de três coordenadas.
  3. Inicializar dois indicadores booleanos:
    • X\_wins \leftarrow \text{False}
    • O\_wins \leftarrow \text{False}
  4. Para cada linha vencedora:
    • Ler os três caracteres dessa linha: a,b,c.
    • Se a=b=c=\;X então X\_wins \leftarrow \text{True}.
    • Se a=b=c=\;O então O\_wins \leftarrow \text{True}.
  5. Contar também se existe pelo menos um espaço em branco no tabuleiro; isto serve para saber se o jogo está incompleto.
  6. Aplicar a regra de decisão final (detalhada no Passo 4) e imprimir exatamente um dos caracteres X, O, I ou E.
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:
  • X\_wins (True/False)
  • O\_wins (True/False)
  • has\_space (True se existe ao menos um caractere \text{ ' ' }, caso contrário False)
Decisão:
  1. Se X\_wins e não O\_wins então imprimir X.
  2. Senão, se O\_wins e não X\_wins então imprimir O.
  3. Senão, se nem X\_wins nem O\_wins e has\_space então imprimir I (incompleto).
  4. Senão (isto é, nem X\_wins nem O\_wins e não há espaços) imprimir E (empate).
Observação sobre casos ambíguos: em um tabuleiro arbitrário pode acontecer que ambas as variáveis X\_wins e O\_wins 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 X):
Linha1: X X X
Linha2: O O \text{ }
Linha3: \text{ } \text{ } \text{ }
Aqui há a linha (0,0),(0,1),(0,2) toda com X → resultado: X.
Exemplo B (vitória de O na diagonal):
Linha1: X X O
Linha2: X O \text{ }
Linha3: O \text{ } \text{ }
A diagonal principal (0,0),(1,1),(2,2) não é toda igual, mas a diagonal secundária (0,2),(1,1),(2,0) é O,O,O → resultado: O.
Exemplo C (incompleto):
Linha1: X O X
Linha2: O X \text{ }
Linha3: O X O
Não há três iguais numa linha; existe pelo menos um espaço → resultado: I.
Exemplo D (empate):
Linha1: X O X
Linha2: O X O
Linha3: O X O
Nenhuma linha vencedora e não há espaços → resultado: E.
Exemplo E (ambíguo — ambos têm linhas): (entrada inválida como jogo)
Linha1: X X X
Linha2: O O O
Linha3: \text{ } \text{ } \text{ }
Aqui X\_wins=True e O\_wins=True. Pelo critério explicado, o algoritmo dará E. 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.

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
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
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))

Exercícios relacionados