Avaliação do TP1 - Parte 1

1) Anderson Solano e Rafael Silva - 8,1
	- Estrutura do Programa (2 pontos)
		- Leitura e escrita a cada volta no laço é ineficiente. Leitura deveria ser feita apenas no início e escrita deveria ser feita apenas ao final (-0,4).
	- Corretude de Funcionamento (3 pontos)
		- Não fizeram testes de divisor maior que dividendo (-0,5).
	- Atendimento da Especificação (2 pontos)
		- OK, exceto por observações de outros itens. 
	- Testes Realizados (2 pontos)
		- Limitaram-se a testes com dados fornecidos (-0,5).
	- Comentários (1 ponto)
		- Comentários de médios a fracos (-0,5).
		
2) Andrey e Matheus - 8,7
	- Estrutura do Programa (2 pontos)
		- Escrita de valores que não mudam é ineficiente e irrelevante (-0,1). Laço principal pouco estruturado, usando processamento externo de inicialização (-0,2).
	- Corretude de Funcionamento (3 pontos)
		- OK, só não funciona para negativos.
	- Atendimento da Especificação - 2 pontos
		- OK, exceto por observações de outros itens.
	- Testes Realizados (2 pontos)
		- Usou 32/5, sem menção a outros testes (-0,2).
	- Comentários (1 ponto)
		- Sem comentários, mas com geração de texto na explicativo na saída (-0,8).
		
3) Bruney - 8,5
	- Estrutura do Programa (2 pontos)
		- Bom, detecta div por 0 e ignora. Leitura e escrita a cada volta no laço é ineficiente. Leitura deveria ser feita apenas no início e escrita deveria ser feita apenas ao final. Além disso, fica modificando o quociente (-0,5).
	- Corretude de Funcionamento (3 pontos)
		- OK.
	- Atendimento da Especificação (2 pontos)
		- OK, exceto por observações de outros itens.
	- Testes Realizados (2 pontos)
		- Usou 10/3, sem menção a outros testes (-0,2).
	- Comentários (1 ponto)
		- Comentários muito pobres e escassos (-0,8).
		
4) Carlos e Leopoldo - 3,5
	- Estrutura do Programa (2 pontos)
		- Não escreve os resultados (-1,0).
	- Corretude de Funcionamento (3 pontos)
		- Não fizeram testes de divisor maior que dividendo (-0,5). Não acumula valores de quociente, sempre inicia com 1 a cada volta do laço (-1,0).
	- Atendimento da Especificação (2 pontos)
		- Não funcionou, algoritmo parece começar bem, mas os erros não foram detectados/corrigidos (-1,5).
	- Testes Realizados (2 pontos)
		- Nada além dos dados fornecidos (-1,5).
	- Comentários (1 ponto)
		- Sem comentários (-1,0).
		
5) Diego - 7,0
	- Estrutura do Programa (2 pontos)
		- Não escreve os resultados, deixa resultados em $t2 (resto) e $t3 (quociente) (-1,0).
	- Corretude de Funcionamento (3 pontos)
		- Não realiza o cálculo quando a divisão é de um número menor por um maior (-0,5)
	- Atendimento da Especificação (2 pontos)
		- OK, exceto por observações de outros itens.
	- Testes Realizados (2 pontos)
		- Limitou-se a testes com dados fornecidos (-0,5).
	- Comentários (1 ponto)
		- Sem comentários (-1,0).
		
6) Eduardo B. Rosa e Fernando Severo - 5,6
	- Estrutura do Programa (2 pontos)
		- OK
	- Corretude de Funcionamento (3 pontos)
		- Programa não funciona, pois inverteram a subtração dividendo-divisor, fazendo divisor-dividendo. Mesmo alterando isto, programa está executando incorretamente (-3,0).
	- Atendimento da Especificação (2 pontos)
		- OK, exceto por observações de outros itens.
	- Testes Realizados (2 pontos)
		- Limitaram-se a testes com dados fornecidos (-0,5).
	- Comentários (1 ponto)
		- Comentários muito pobres, com afirmações incorretas e escassos (-0,9).
		
6) Eduardo Diederichsen e Rafael Godoy - 9,3
	- Estrutura do Programa (2 pontos)
		- A construção j loop imediatamente antes da  linha com o rótulo loop é absolutamente inútil, denota baixo nível de compreensão de técnicas de programação (-0,3). Testar se o dividendo é 0 é irrelevante se o algoritmo for executado corretamente (-0,2). O teste mais importante  para ver se o divisor é 0 não foi contudo realizado. 
	- Corretude de Funcionamento (3 pontos)
		- OK.
	- Atendimento da Especificação (2 pontos)
		- OK, exceto por observações de outros itens.
	- Testes Realizados (2 pontos)
		- Usou 10/3, sem menção a outros testes (-0,2).
	- Comentários (1 ponto)
		- OK.
		
8) Fabio - 6,0
	- Estrutura do Programa (2 pontos)
		- Leituras de variáveis OK. Teste de divisor=0 OK. Não atualizou resto nem memória com valores (-1,0)
	- Corretude de Funcionamento (3 pontos)
		- Teste se divisor menor que quociente não faz sentido, deveria testar se dividendo menor que divisor. Subtração idem, deveria ser de dividendo menos divisor. (-1,0) 
	- Atendimento da Especificação (2 pontos)
		- OK, exceto por observações de outros itens.
	- Testes Realizados (2 pontos)
		- Programa entra em laço eterno (-1,0).
	- Comentários (1 ponto)
		- Sem comentários (-1,0).
		
9) Jeferson e Fernando Delazeri - 7,9
	- Estrutura do Programa (2 pontos)
		- Escritas a cada volta no laço são ineficientes. Deveriam ser feitas apenas ao final (-0,4).
	- Corretude de Funcionamento (3 pontos)
		- Calculando o resto certo, mas o quociente erra sempre com uma  unidade a  menos. Por exemplo, 15/4 da 2 resto 3 no programa, quando o certo seria dar 3 resto 3 (-1,5) 
	- Atendimento da Especificação (2 pontos)
		- OK, exceto por observações de outros itens.
	- Testes Realizados (2 pontos)
		- OK, testaram alguns valores.
	- Comentários (1 ponto)
		- Apenas razoáveis (-0,2).
		
10) Guilherme Jacondino e Lucas Nunes - 8.1
	- Estrutura do Programa (2 pontos)
		- A construção j loop imediatamente após a  linha com o rótulo loop é absolutamente inútil, denota baixo nível de compreensão de técnicas de programação (-0,3). o mesmo vale para j Acabou. Código sem identação (-0,2)
	- Corretude de Funcionamento (3 pontos)
		- 0/6 dá 0 resto 0 (-0,5)
		- 6/0 faz programa ficar em laço. Erro vem de testar o dividendo achando que  se trata do divisor. 
	- Atendimento da Especificação (2 pontos)
		- OK, exceto por observações de outros itens.
	- Testes Realizados (2 pontos)
		- Limitaram-se a testes com dados fornecidos (-0,5).
	- Comentários (1 ponto)
		- Comentários razoáveis, mas com afirmações incorretas (-0,4).
		
11) Lucas Colombo e Patrick Kern - 7,7
	- Estrutura do Programa (2 pontos)
		- Impressões ao final não fazem sentido (-0,3).
	- Corretude de Funcionamento (3 pontos)
		- 3/10 dá 0 resto 0, erradamente (-0,5). Divisão por 0 gera loop eterno.
	- Atendimento da Especificação (2 pontos)
		- OK, exceto por observações de outros itens.
	- Testes Realizados (2 pontos)
		- Limitaram-se a testes com dados fornecidos (-0,5).
	- Comentários (1 ponto)
		- Sem comentários (-1,0).
		
12) Luis Roza e Thomas Sieczkowski - 8,8
	- Estrutura do Programa (2 pontos)
		- OK
	- Corretude de Funcionamento (3 pontos)
		- 3/10 dá 0 resto 0, erradamente (-0,5). Divisão por 0 gera loop eterno.
	- Atendimento da Especificação (2 pontos)
		- OK, exceto por observações de outros itens.
	- Testes Realizados (2 pontos)
		- Usou 10/3, sem menção a outros testes (-0,2).
	- Comentários (1 ponto)
		- Comentários de médios mas escassos e não-semânticos (-0,5).
		
13) Maria e Sani - 6,8
	- Estrutura do Programa (2 pontos)
		- Sem escritas nas variáveis em memória (-0,5)
	- Corretude de Funcionamento (3 pontos)
		- 3/10 dá 0 resto 0, erradamente (-0,5). Divisão por 0 gera loop eterno.
	- Atendimento da Especificação (2 pontos)
		- Não escreveram os resultados, deixaram-nos em $t2 (resto) e $t3 (quociente) (-1,0).
	- Testes Realizados (2 pontos)
		- Usaram 10/3, sem menção a outros testes (-0,2).
	- Comentários (1 ponto)
		- Praticamente sem comentários (-1,0).
		
14) Thomas Fuentefria e Vinicius - 6,1
	- Estrutura do Programa (2 pontos)
		- Escrita de valores que não mudam é ineficiente e irrelevante (-0,1).
	- Corretude de Funcionamento (3 pontos)
		- 0/3 dá  valor  completamente maluco, 0xfffffffd (-1,0).
	- Atendimento da Especificação (2 pontos)
		- 0 dividido por um número maior  que zero deveria funcionar (-0,3)
	- Testes Realizados (2 pontos)
		- Limitaram-se a testes com dados fornecidos (-0,5).
	- Comentários (1 ponto)
		- Sem comentários (-1,0).