1 Critérios de correção EP2

Os descontos aplicados se dividem em dois tipos: descontos por teste de unidade e descontos por detalhes de implementação. O primeiro tipo de desconto é aplicado quando a implementação de uma função específica não retorna o valor desejado ou altera um objeto indesejado; esses descontos foram aplicados automaticamente através de um programa corretor. O segundo tipo de desconto refere-se a critérios gerais, como presença de funções não permitidas, ausência de funções requisitadas, implementação ruim (código muito complexo ou muito ineficiente) ou falta de identificação.

1.1 Descontos por teste de unidade de funções [Desconto máximo: 7 pontos]

Esses testes verificam se uma determinada função se comporta como esperado, independentemente de sua implementação. Para isso, a função é chamada com um conjunto pré-determinado de entradas e sua saída (ou os valores modificados pela função) é (são) comparada(os) contra o gabarito. Se qualquer chamada da função resultar em um resultado diferente do esperado o desconto correspondente é aplicado.

1.1.1 criar [0,5 ponto]

Verifica se função retorna uma matriz com as dimensões corretas e se todos elementos são strings vazias.

Chamadas testadas:

criar(3,3), criar(4,4), criar(8,8), criar(9,9), criar(10,10)

1.1.2 trocar [1,5 pontos]

Verifica se o tabuleiro é modificado corretamente (0,5 ponto) e se a validade da troca é determinada corretamente (1,0 ponto).

1.1.2.1 Casos de teste

# troca gera cadeia horizontal (válida)
trocar(1,2,2,2,     [['C','C','B'],
                     ['B','C','A'],
                     ['A','A','B']])
# Esperado:
True,     [['C', 'C', 'B'],
           ['B', 'C', 'B'],
           ['A', 'A', 'A']]
# troca gera cadeia vertical (válida)                     
trocar(1,2,1,1,     [['C','C','B'],
                     ['B','B','A'],
                     ['A','A','B']])
Esperado:                     
True,     [['C','C','B'],
           ['B','A','B'],
           ['A','A','B']]
# troca não gera cadeia (inválida)                     
trocar(0,2,2,3,     [['C','C','B'],
                     ['B','C','A'],
                     ['A','A','B']])
# Esperado
False,    [['C','C','B'],
           ['B','C','A'],
           ['A','A','B']]
# posições não adjacentes (inválida)          
trocar(1,2,2,0,      [['C','C','B'],
                      ['B','C','A'],
                      ['A','A','B']])
# Esperado:
False,   [['C','C','B'],
          ['B','C','A'],
          ['A','A','B']]
# posições não adjacentes (inválida)          
trocar(1,0,1,2,      [['C','C','B'],
                      ['B','C','A'],
                      ['A','A','B']])
# Esperado:
False, [['C','C','B'],
        ['B','C','A'],
        ['A','A','B']]

1.1.3 identificar_cadeias_horizontais [0,5 ponto]

O desconto é aplicado se uma cadeia esperada não é encontrada ou se uma cadeia encontrada não é esperada. Também existe desconto se o tabuleiro é alterado.

# nenhuma cadeia
identificar_cadeias_horizontais([['C','C','B'],
                                 ['B','C','B'],
                                 ['A','A','B']])
# Esperado:
[]     
# 1 cadeia                            
identificar_cadeias_horizontais([['C','C','B'],
                                 ['B','C','B'],
                                 ['A','A','A']])
# Esperado:
[[2, 0, 2, 2]]
# 1 cadeia (ignorar cadeia vertical)
identificar_cadeias_horizontais([['C','C','A'],
                                 ['B','B','A'],
                                 ['A','A','A']],
# Esperado:
[[2, 0, 2, 2]]
# 2 cadeias
identificar_cadeias_horizontais([['C','C','C'],
                                 ['B','C','B'],
                                 ['A','A','A']])
# Esperado:
[[0, 0, 0, 2], [2, 0, 2, 2]]),
# 1 cadeia de 4 em tabuleiro assimétrico
identificar_cadeias_horizontais([['C','C','C','C'],
                                 ['B','C','B','B'],
                                 ['A','A','B','C']])
# Esperado:
[[0, 0, 0, 3]]
# duas cadeias em "cantos"
identificar_cadeias_horizontais([['B', 'B', 'B', 'F', 'G', 'D', 'B', 'C'],
                                 ['A', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
                                 ['G', 'F', 'G', 'D', 'G', 'A', 'G', 'A'],
                                 ['C', 'C', 'G', 'C', 'A', 'B', 'A', 'F'],
                                 ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'A'],
                                 ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
                                 ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
                                 ['A', 'C', 'A', 'E', 'E', 'F', 'F', 'F']])
# Esperado:
[[0, 0, 0, 2], [7, 5, 7, 7]]
# duas cadeias com mais de 3 gemas
identificar_cadeias_horizontais([['B', 'B', 'B', 'B', 'G', 'D', 'B', 'C'],
                                 ['A', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
                                 ['G', 'F', 'G', 'D', 'G', 'A', 'G', 'A'],
                                 ['C', 'C', 'G', 'C', 'A', 'B', 'A', 'F'],
                                 ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'A'],
                                 ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
                                 ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
                                 ['A', 'C', 'A', 'E', 'F', 'F', 'F', 'F']])
# Esperado:
[[0, 0, 0, 3], [7, 4, 7, 7]]

1.1.4 identificar_cadeias_verticais [0,5 ponto]

O desconto é aplicado se uma cadeia esperada não é encontrada ou se uma cadeia encontrada não é esperada. Também existe desconto se o tabuleiro é alterado.

# nenhuma cadeia
identificar_cadeias_verticais( [['C','C','B'],
                                ['B','C','B'],
                                ['A','A','A']])
# Esperado:
[]
# 1 cadeia
identificar_cadeias_verticais( [['C','C','B'],
                                ['B','C','B'],
                                ['A','A','B']])
# Esperado:
[[0, 2, 2, 2]]
# 1 cadeia (ignorar cadeia horizontal)
identificar_cadeias_verticais( [['C','C','A'],
                                ['B','B','A'],
                                ['A','A','A']])
# Esperado:
[[0, 2, 2, 2]]
# 2 cadeias
identificar_cadeias_verticais( [['C','C','B'],
                                ['B','C','B'],
                                ['A','C','B']])
# Esperado:
[[0, 2, 2, 2],[0, 1, 2, 1]]

1.1.5 eliminar_cadeia [0,5 ponto]

Desconto aplicado se tabuleiro ou número de gemas eliminadas difere do esperado.

1.1.5.1 Casos possíveis durante o jogo [0,3 ponto]

eliminar_cadeia([['C','C','B'],
                 ['B','C','B'],
                 ['A','C','C']],[0,1,2,1])
# Esperado:
3,[['C',' ','B'],
   ['B',' ','B'],
   ['A',' ','C']]
# cadeia vertical no início (com coluna no meio não eliminada)
eliminar_cadeia([['C','C','B'],
                 ['C','C','B'],
                 ['C','C','C']],[0,0,2,0])
# Esperado:
3,[[' ','C','B'],[' ','C','B'],[' ','C','C']]
# cadeia vertical no fim (com coluna no meio não eliminada)
eliminar_cadeia([['C','C','B'],
                 ['B','C','B'],
                 ['A','C','B']],[0,2,2,2])
# Esperado:
3,[['C','C',' '],
   ['B','C',' '],
   ['A','C',' ']]
# cadeia horizontal no meio             
eliminar_cadeia([['C','C','B'],
                 ['B','B','B'],
                 ['A','C','C']],[1,0,1,2])
# Esperado:
3,[['C','C','B'],
   [' ',' ',' '],
   ['A','C','C']]
# cadeia horizontal no fim             
eliminar_cadeia([['C','C','B'],
                 ['B','B','B'],
                 ['A','A','A']],[2,0,2,2])
# Esperado:
3,[['C','C','B'],['B','B','B'],[' ',' ',' ']]
# cadeia horizontal no começo
eliminar_cadeia([['B', 'B', 'B', 'F', 'G', 'D', 'B', 'C'],
                 ['A', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
                 ['G', 'F', 'G', 'D', 'G', 'A', 'G', 'A'],
                 ['C', 'C', 'G', 'C', 'E', 'B', 'A', 'F'],
                 ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'A'],
                 ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
                 ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
                 ['A', 'C', 'A', 'E', 'E', 'F', 'F', 'F']],[0, 0, 0, 2])
# Esperado:
3,[[' ', ' ', ' ', 'F', 'G', 'D', 'B', 'C'],
   ['A', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
   ['G', 'F', 'G', 'D', 'G', 'A', 'G', 'A'],
   ['C', 'C', 'G', 'C', 'E', 'B', 'A', 'F'],
   ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'A'],
   ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
   ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
   ['A', 'C', 'A', 'E', 'E', 'F', 'F', 'F']]

1.1.5.2 Casos incomuns durante o jogo [0,2 ponto]

# cadeia vertical no meio com gemas eliminadas
eliminar_cadeia([['C','C','B'],
                 [' ',' ',' '],
                 ['A','C','C']],[0,1,2,1])
# Esperado:
2,[['C',' ','B'],
   [' ',' ',' '],
   ['A',' ','C']]
# cadeia horizontal no meio vazia
eliminar_cadeia([['C','C','B'],
                 [' ',' ',' '],
                 ['A','C','C']],[1,0,1,2])
# Esperado:
0,[['C','C','B'],
   [' ',' ',' '],
   ['A','C','C']]
# cadeia horizontal no início vazia
eliminar_cadeia([[' ', ' ', ' ', 'F', 'G', 'D', 'B', 'C'],
                 ['A', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
                 ['G', 'F', 'G', 'D', 'G', 'A', 'G', 'A'],
                 ['C', 'C', 'G', 'C', 'E', 'B', 'A', 'F'],
                 ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'A'],
                 ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
                 ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
                 ['A', 'C', 'A', 'E', 'E', 'F', 'F', 'F']],[7, 0, 7, 7])
# Esperado:
8,[[' ', ' ', ' ', 'F', 'G', 'D', 'B', 'C'],
   ['A', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
   ['G', 'F', 'G', 'D', 'G', 'A', 'G', 'A'],
   ['C', 'C', 'G', 'C', 'E', 'B', 'A', 'F'],
   ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'A'],
   ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
   ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
   [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']]

1.1.6 eliminar [0,5 ponto]

Desconto aplicado se tabuleiro ou número de gemas eliminadas difere do esperado.

# nenhuma
eliminar([['B', 'B', 'D', 'F', 'G', 'D', 'B', 'C'],
          ['A', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
          ['G', 'F', 'G', 'D', 'G', 'A', 'G', 'A'],
          ['C', 'C', 'G', 'C', 'E', 'B', 'A', 'F'],
          ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'A'],
          ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
          ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
          ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']])
# Esperado:
0,[['B', 'B', 'D', 'F', 'G', 'D', 'B', 'C'],
   ['A', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
   ['G', 'F', 'G', 'D', 'G', 'A', 'G', 'A'],
   ['C', 'C', 'G', 'C', 'E', 'B', 'A', 'F'],
   ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'A'],
   ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
   ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
   ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']]
# eliminar colunas vertical e horizontal
eliminar([['B', 'B', 'D', 'F', 'G', 'D', 'B', 'C'],
          ['A', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
          ['G', 'F', 'G', 'D', 'G', 'A', 'G', 'A'],
          ['C', 'C', 'C', 'G', 'E', 'B', 'A', 'A'],
          ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'A'],
          ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
          ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
          ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']])
# Esperado:
6,[['B', 'B', 'D', 'F', 'G', 'D', 'B', 'C'],
   ['A', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
   ['G', 'F', 'G', 'D', 'G', 'A', 'G', ' '],
   [' ', ' ', ' ', 'G', 'E', 'B', 'A', ' '],
   ['B', 'D', 'A', 'D', 'F', 'D', 'A', ' '],
   ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
   ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
   ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']]
# eliminar L
eliminar([['A','A','A'],
          ['B','B','A'],
          ['B','B','A']])
# Esperado:
5,[[' ',' ',' '],
   ['B','B',' '],
   ['B','B',' ']]
# eliminar T
eliminar([['A','A','A'],
          ['B','A','B'],
          ['B','A','B']])
# Esperado:
5,[[' ',' ',' '],
   ['B',' ','B'],
   ['B',' ','B']]

1.1.7 deslocar_coluna [1 ponto]

Desconto aplicado se tabuleiro difere do esperado.

deslocar_coluna(
[['B', 'B', 'D', 'F', 'G', 'D', 'B', 'C'],
 ['A', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
 ['G', 'F', 'G', 'D', 'G', 'A', 'G', ' '],
 [' ', ' ', ' ', 'G', 'B', 'B', 'A', ' '],
 ['B', 'D', 'A', 'D', 'F', 'D', 'A', ' '],
 ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
 ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
 ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']],0)
# Esperado:
[[' ', 'B', 'D', 'F', 'G', 'D', 'B', 'C'],
 ['B', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
 ['A', 'F', 'G', 'D', 'G', 'A', 'G', ' '],
 ['G', ' ', ' ', 'G', 'B', 'B', 'A', ' '],
 ['B', 'D', 'A', 'D', 'F', 'D', 'A', ' '],
 ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
 ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
 ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']]

deslocar_coluna(
[[' ', 'B', 'D', 'F', 'G', 'D', 'B', 'C'],
 ['B', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
 ['A', 'F', 'G', 'D', 'G', 'A', 'G', ' '],
 ['G', ' ', ' ', 'G', 'B', 'B', 'A', ' '],
 ['B', 'D', 'A', 'D', 'F', 'D', 'A', ' '],
 ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
 ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
 ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']],7)
# Esperado:
[[' ', 'B', 'D', 'F', 'G', 'D', 'B', ' '],
 ['B', 'D', 'C', 'F', 'A', 'A', 'E', ' '],
 ['A', 'F', 'G', 'D', 'G', 'A', 'G', ' '],
 ['G', ' ', ' ', 'G', 'B', 'B', 'A', 'C'],
 ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'C'],
 ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
 ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
 ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']]

deslocar_coluna(
[[' ', 'B', 'D', 'F', 'G', 'D', 'B', ' '],
 ['B', 'D', 'C', 'F', 'A', 'A', 'E', ' '],
 ['A', 'F', 'G', 'D', 'G', 'A', 'G', ' '],
 ['G', ' ', ' ', 'G', 'B', 'B', 'A', 'C'],
 ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'C'],
 ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
 ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
 ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']],0)
# Esperado:
[[' ', 'B', 'D', 'F', 'G', 'D', 'B', ' '],
 ['B', 'D', 'C', 'F', 'A', 'A', 'E', ' '],
 ['A', 'F', 'G', 'D', 'G', 'A', 'G', ' '],
 ['G', ' ', ' ', 'G', 'B', 'B', 'A', 'C'],
 ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'C'],
 ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
 ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
 ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']]

deslocar_coluna(
[['A','A','A'],
 ['A',' ','A'],
 ['A','A','A'],
 ['A',' ','A']],1)
# Esperado:
[['A',' ','A'],
 ['A',' ','A'],
 ['A','A','A'],
 ['A','A','A']]

1.1.8 deslocar [0,5 ponto]

Desconto aplicado se tabuleiro difere do esperado.

deslocar([['B', 'B', 'D', 'F', 'G', 'D', 'B', 'C'],
          ['A', 'D', 'C', 'F', 'A', 'A', 'E', 'C'],
          ['G', 'F', 'G', 'D', 'G', 'A', 'G', ' '],
          [' ', ' ', ' ', 'G', 'B', 'B', 'A', ' '],
          ['B', 'D', 'A', 'D', 'F', 'D', 'A', ' '],
          ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
          ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
          ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']])
# Esperado:
[[' ', ' ', ' ', 'F', 'G', 'D', 'B', ' '],
 ['B', 'B', 'D', 'F', 'A', 'A', 'E', ' '],
 ['A', 'D', 'C', 'D', 'G', 'A', 'G', ' '],
 ['G', 'F', 'G', 'G', 'B', 'B', 'A', 'C'],
 ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'C'],
 ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
 ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
 ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']]

1.1.9 obter_dica [1,0 ponto]

1.1.9.1 Desconto por tipo de dado retornado [0,1 ponto]

x = obter_dica([['A','B','C'],
                ['C','A','B'],
                ['B','C','A']])
# Esperado
type(x) == type(tuple())

1.1.9.2 Desconto por modificação no tabuleiro ou valore de retorno incorreto [0,9 ponto]

obter_dica([['A', 'D', 'F'],
            ['G', 'D', 'E'],
            ['A', 'C', 'D']])
# Esperado:           
(2,1)
# ou
(2,2)
obter_dica([['A','B','C'],
            ['C','A','B'],
            ['B','C','A']])
# Esperado:
(-1,-1)

1.1.10 existem_movimentos_validos [0,5 ponto]

Desconto aplicado se valor de retorno é incorreto ou e tabuleiro é modificado.

existem_movimentos_validos([['A', 'D', 'F', 'F', 'G', 'D', 'B', 'C'],
                            ['B', 'B', 'D', 'F', 'A', 'A', 'E', 'A'],
                            ['A', 'D', 'C', 'D', 'G', 'A', 'G', 'E'],
                            ['G', 'F', 'G', 'G', 'B', 'B', 'A', 'B'],
                            ['B', 'D', 'A', 'D', 'F', 'D', 'A', 'C'],
                            ['G', 'D', 'E', 'C', 'D', 'B', 'G', 'G'],
                            ['E', 'C', 'B', 'A', 'D', 'G', 'A', 'E'],
                            ['A', 'C', 'A', 'E', 'E', 'A', 'F', 'F']])
# Esperado:
True
existem_movimentos_validos( [['A','B','C'],
                             ['C','A','B'],
                             ['B','C','A']])
# Esperado:
False
existem_movimentos_validos( [['A','A','A'],
                             ['C','A','B'],
                             ['B','C','A']])
# Esperado:
True

1.2 Descontos por detalhes de implementação [Desconto máximo: 2,5 pontos]

Esses descontos referem-se a implementações que não estavam em acordo com o especificado no enunciado tais como:

  • uso de funções não permitidas [0,5 ponto]
  • não uso de funções requisitadas [0,5 ponto]
  • código muito complexo ou gastando recursos de forma muito desnecessária [0,5 ponto]
  • ausência de identificação (número USP, nome e turma) [0,5 ponto]
  • impressão errada do tabuleiro [0,5 ponto]
Última atualização: terça-feira, 27 jun. 2017, 15:11