Você provavelmente já conhece o jogo Sudoku. Em sua forma mais tradicional, um diagrama com 9x9 posições deve ser preenchido com algarismos de 1 a 9. Não pode haver repetições nas linhas, nas colunas e nem nas células de dimensão 3x3.
Se você jogou Sudoku no computador e inseriu um algarismo que desrespeitasse as regras do jogo, provavelmente recebeu um alerta. Seu objetivo nesta tarefa será implementar este auxílio aos jogadores: dado um diagrama parcialmente preenchido, você deverá colocar as ocorrências inválidas em evidência.
A entrada será composta por 9 linhas com 9 elementos cada
uma. Posições não preenchidas serão representadas pelo
caractere _ e posições preenchidas conterão
algarismos. Veja o exemplo abaixo:
8 _ 6 _ 6 3 _ 9 _
_ 4 _ _ 1 _ _ 6 8
2 _ _ 8 7 _ _ _ 5
1 _ 8 _ _ 5 _ 2 _
8 3 _ 1 _ _ _ 5 _
7 _ 5 _ 3 _ 9 _ _
_ 2 1 _ _ 7 _ 4 _
6 _ _ _ 2 _ 8 3 _
_ 8 7 6 _ 4 _ _ 3
A saída reapresentará o diagrama com bordas separando os elementos
e as células. Os elementos que aparecerem repetidos nas linhas,
colunas e/ou células estarão marcados com caracteres *. O
exemplo abaixo mostra o resultado esperado a partir da entrada da
seção anterior:
+---------------------+---------------------+---------------------+
| +-----+-----+-----+ | +-----+-----+-----+ | +-----+-----+-----+ |
| | *8* | _ | *6* | | | _ | *6* | 3 | | | _ | 9 | _ | |
| +-----+-----+-----+ | +-----+-----+-----+ | +-----+-----+-----+ |
| | _ | 4 | _ | | | _ | 1 | _ | | | _ | 6 | 8 | |
| +-----+-----+-----+ | +-----+-----+-----+ | +-----+-----+-----+ |
| | 2 | _ | _ | | | 8 | 7 | _ | | | _ | _ | 5 | |
| +-----+-----+-----+ | +-----+-----+-----+ | +-----+-----+-----+ |
+---------------------+---------------------+---------------------+
| +-----+-----+-----+ | +-----+-----+-----+ | +-----+-----+-----+ |
| | 1 | _ | *8* | | | _ | _ | 5 | | | _ | 2 | _ | |
| +-----+-----+-----+ | +-----+-----+-----+ | +-----+-----+-----+ |
| | *8* | 3 | _ | | | 1 | _ | _ | | | _ | 5 | _ | |
| +-----+-----+-----+ | +-----+-----+-----+ | +-----+-----+-----+ |
| | 7 | _ | 5 | | | _ | 3 | _ | | | 9 | _ | _ | |
| +-----+-----+-----+ | +-----+-----+-----+ | +-----+-----+-----+ |
+---------------------+---------------------+---------------------+
| +-----+-----+-----+ | +-----+-----+-----+ | +-----+-----+-----+ |
| | _ | 2 | 1 | | | _ | _ | 7 | | | _ | 4 | _ | |
| +-----+-----+-----+ | +-----+-----+-----+ | +-----+-----+-----+ |
| | 6 | _ | _ | | | _ | 2 | _ | | | 8 | *3* | _ | |
| +-----+-----+-----+ | +-----+-----+-----+ | +-----+-----+-----+ |
| | _ | 8 | 7 | | | 6 | _ | 4 | | | _ | _ | *3* | |
| +-----+-----+-----+ | +-----+-----+-----+ | +-----+-----+-----+ |
+---------------------+---------------------+---------------------+
O código do seu programa pode ficar bem mais fácil de ser lido e depurado se estiver subdividido em funções. Para esta tarefa, o desenvolvimento de funções auxiliares para a resolução do problema será obrigatório.
Esta tarefa contém 8 testes abertos e 2 testes fechados. Releia, se necessário, as instruções para fazer os testes em Testes com o SuSy.
Veja aqui a
página de submissão da tarefa. O arquivo a ser
submetido deve se chamar lab12.py. No
link Arquivos
auxiliares há um
arquivo aux12.zip que
contém todos os arquivos de testes abertos, seus respectivos
resultados compactados e scripts para facilitar os testes.
O limite máximo será de 20 submissões. Serão considerados os resultados da última submissão.
O peso desta tarefa é 5.
O prazo final para submissão é 30/06/2019.
A nota desta tarefa é proporcional ao número de testes que executaram corretamente, desde que o código esteja coerente com o enunciado. A submissão de um código que não implementa o algoritmo requisitado, mas que exibe as saídas esperadas dos testes abertos a partir da comparação de trechos da entrada será considerada fraude e acarretará a atribuição de nota zero à média final da disciplina.