1. Introdução

O objetivo é implementar uma versão do jogo Campo Minado, incluindo a construção do tabuleiro e a implementação de jogadores (humano e automático). Antes de começar, recomenda-se jogar algumas partidas em uma implementação conhecida para compreender as regras.

2. Regras do jogo

O jogo é jogado em um tabuleiro quadriculado (matriz n × m) com k minas posicionadas aleatoriamente. O jogador revela posições até encontrar todas as minas ou até revelar uma posição com mina (perdendo).

Comportamento ao revelar uma posição

• Se a posição contém uma mina → jogador perde; o tabuleiro revela todas as minas.
• Se a posição não contém mina → a posição é rotulada com o número de minas nas oito posições adjacentes.
• Se esse número for zero → todas as posições adjacentes são reveladas recursivamente (efeito “expansão”).

Observação: o jogo deve garantir que a primeira escolha do jogador nunca seja uma posição com mina.

3. Especificação do exercício

Implementar as seguintes classes em Java, respeitando as interfaces pedidas para permitir testes automáticos:

3.1 Classe Tabuleiro

A classe Tabuleiro deve oferecer os construtores e métodos abaixo.

// Construtores:
public Tabuleiro(int n, int m, int k);
public Tabuleiro(int i);

// Métodos de acesso:
public int numLinhas();
public int numColunas();
public int numMinas();

// Métodos de usuário:
public int numPosRestantes();
public int numPosReveladas();
public int numJogadas();
public boolean fim();
public boolean ganhou();
public boolean perdeu();
public void recomeca();
public void imprimeTabuleiro();
public int jogada(int i, int j);

Comportamento do construtor: Tabuleiro(int i) cria níveis predefinidos:

• Fácil: n=8, m=8, k=10 (i = 1)
• Médio: n=16, m=16, k=40 (i = 2)
• Difícil: n=16, m=30, k=99 (i = 3)

Se os parâmetros do construtor com três inteiros não forem viáveis, criar um tabuleiro de nível fácil.

Retorno do método jogada

• -1 → posição contém mina (jogador perdeu)
• 0 → todas as posições foram reveladas (jogador venceu)
• 1 → posição foi revelada com sucesso
• 2 → posição já havia sido revelada antes
• -2 → parâmetros inválidos

Após fim da partida, jogada deve sempre devolver o mesmo valor (0 ou -1).

3.1.1 Representação do tabuleiro

Sugestão de representação por matriz de inteiros com valores:

• -2 → posição contém mina;
• -1 → posição não contém mina e não foi revelada;
• i (0 ≤ i ≤ 8) → posição revelada com i minas nas 8 vizinhas.

Dica: crie uma moldura (borda) e use matriz de tamanho (n+2) × (m+2) para simplificar verificações de vizinhança.

3.1.2 Exemplo de uso

> Tabuleiro tab = new Tabuleiro(1);
> tab.jogada(1,7)
1
> tab.imprimeTabuleiro()
1 2 3 4 5 6 7 8
/-----------------\
1 | + + 1 0 0 0 0 0 | 1
2 | + + 3 2 1 1 0 0 | 2
3 | + + + + + 1 0 0 | 3
4 | + + 3 2 1 1 0 0 | 4
5 | + + 1 0 0 0 1 1 | 5
6 | + + 3 2 1 1 2 + | 6
7 | + + + + + + + + | 7
8 | + + + + + + + + | 8
\-----------------/

3.2 Classe JogadorHumano

Permitir que uma pessoa jogue via teclado. Cada objeto deve oferecer o método public void iniciaJogo(), que conduz a partida, pedindo nível (ou tabuleiro personalizado) e coordenadas a cada iteração.

3.3 Classe JogadorAutomatico

Deve fornecer o método public boolean iniciaJogo(Tabuleiro t), que joga a partida no tabuleiro t e retorna true se vencer. Estratégia simples (aleatória) é aceitável; estratégias mais inteligentes são opcionais.

4. Itens opcionais

• Marcar o tempo do jogo;
• Adicionar marcação de posições suspeitas (flags);
• Tornar o jogador automático mais inteligente;
• Criar interface gráfica.

5. Observações importantes

Sobre elaboração: o trabalho pode ser feito em dupla com programação pareada; siga as regras de cooperação descritas no enunciado.

Sobre entrega: escreva cada classe em arquivo separado e inclua o cabeçalho sugerido no início de cada arquivo.

6. Critérios de avaliação e entrega

• Exercícios copiados receberão nota ZERO.
• Exercícios atrasados não serão aceitos.
• Qualidade de comentários, indentação e clareza das saídas influenciam a nota.
• Prazo de entrega: 27/06/2026.

7. Cabeçalho sugerido para arquivos

/***********************************************************/
 /**
 Exercício-Programa -- Campo Minado
 Arquivo: <nome do arquivo>
 <nome do(a) aluno(a)>
 <número do(a) aluno(a)>
 <data de entrega>
 /***********************************************************/

Repositórios para aprender AI/ML

Autor: Herez

Este post reúne descrições práticas de repositórios que eu, Herez, utilizei para estudar inteligência artificial e aprendizado de máquina. Para cada repositório há uma explicação objetiva e um exemplo real de como o utilizei para aprender, experimentar ou aplicar conceitos.

Como eu recomendo usar esses repositórios

• Monte um plano de estudos prático: combine um repositório teórico (papers/anotações) com um repositório de projetos práticos.
• Reproduza experimentos mínimos: implemente versões reduzidas dos exemplos antes de tentar reproduzir o pipeline completo.
• Documente tudo: mantenha um diário de experimentos com comandos, parâmetros e resultados para acelerar aprendizado.
• Integre aprendizado com projetos reais: aplique conceitos em pequenos projetos que resolvam problemas concretos.

Este post foi redigido por Herez e apresenta experiências e exemplos práticos utilizados por ele para aprender e aplicar técnicas de IA/ML.