Criada: 2017-11-04
Modificada: 2017-11-05 (Prova Haskell Q1)
Modificada: 2017-11-12 (Prova Haskell Q2)
Modificada: 2017-11-18 (Prova Haskell Q3)
Modificada: 2017-11-20 (Gabarito melhor para Q4)
Enunciado distribuído na sala (com as correções feitas na sala nos exemplos da questão 4).
%%% questao 1
main = do
line <- getLine
if line == ""
then return ()
else do
putStrLn $ "caracs= " ++ caracs line ++ " pals= " ++ pals line
main
caracs :: String -> String
caracs = show . length
pals :: String -> String
pals = show . length . words
%%% questao 2
mesmaSoma :: [ [ Int ] ] -> Bool
mesmaSoma = same . map sum
same :: [ Int ] -> Bool
same [] = True
same (x:xs) = all (==x) xs
%%% questao 3
data Tree = Nil | Node String Tree Tree deriving (Eq, Read, Show)
insere :: String -> Tree -> Tree
insere x Nil = Node x Nil Nil
insere x (Node r esq dir)
| x == r = Node r esq dir
| x < r = Node r (insere x esq) dir
| x > r = Node r esq (insere x dir)
%%% questao 4
part :: Int -> Int -> [ [ Int ] ]
part k n = part' (max 1 k) n
part' :: Int -> Int -> [ [ Int ] ]
part' k n
| n == 0 = [[]]
| k > n = []
| otherwise = (map (k:) $ part k (n - k)) ++ part' (k + 1) n
Em todas as questões, o critério de correção começou por decidir como seria a pontuação: de cima para baixo ou de baixo para cima. Se a resposta estava bem escrita, com sintaxe Lisp correta, resolução do problema pedido (e não de outro) e com comprimento proporcional à complexidade da questão, então a correção procedeu de cima para baixo, ou seja, parte-se do valor integral e vão sendo subtraidas frações de pontos para cada defeito encontrado.
Por outro lado, se a resposta estava mal escrita, com sintaxe errada, resolvendo o problema errado ou incompleta, então a correção procedeu de baixo para cima: parte-se de zero e vão sendo adicionadas frações de pontos a cada indício de conhecimento importante encontrado.
A seguir, critérios específicos para cada questão. Os valores negativos se aplicam à correção de cima para baixo, e os valores positivos ou nulos se aplicam à correção de baixo para cima.
a digitar
não repete -1,0
faltou main -0,5
=/= ou != em vez de /= -0,1
+ em vez de ++ -0,2
faltou show -0,5
guardas fora de função -0,5
duplo otherwise -0,5
inicial maiúscula em variável -0,2
aspas em vez de apóstrofes -0,2
colchetes em vez de parênteses, ou a mais -0,5
=> em vez de -> -0,2
uso de variável não inicializada ou fora de escopo -0,5
@ em lugar errado -0,2
conta brancos ou séries de brancos em vez de palavras -0,5
if sem else -0,5
tipos diferentes em then e else -0,5
não conta brancos como carateres -0,5
função não definida até -1,5
problema na parada -0,5
uso errôneo de read -0,5
uso de unword em vez de words -0,2
faltou return -0,5
usou intToDigit em vez de show -0,5
usou . em vez de $ -0,5
takeWords em vez de words -0,1
uso errado de let -0,5
read em lugar de getLine -0,5
faltou do, ou inverteu main e do -0,5
uso de while (não existe) -1,0
faltou ou sobrou $ -0,5
erro em assinatura/parâmetros -0,5
faltou = -0,5
False/True em minúsculas -0,2
não conta última palavra -0,5
depende de branco no final da linha -0,5
Data.List em vez de Data.Char -0,5
não conta palavras -1,0
sintaxe -0,5
sum deveria estar fora da lista -0,5
fez main +0,5
repetição recusriva +0,5
true em vez de True -0,1
erro em assinatura -0,1 a -0,5
xs em vez de x:xs -0,5
erro em caso base: lista vazia -0,5
erro em caso case: lista unitária -0,5
comparação entre tipos diferentes -0,5
return usado erradamente -0,5
mistura de indicador de primeira vez com soma -0,5
potencial de divisão por zero -0,5
faltou import -0,5
uso errado de $ -0,5
uso de fst para lista -0,5
filter em vez de map -0,5
uso de Int como classe de tipos -0,5
if sem else -0,5
sintaxe -0,5
discordância de argumentos -0,5 a -1,0
erro de tipo -1,0
estratégia errada: média -1,0
apenas para listas de 2 ou mais listas -1,0
confusão entre lista e tupla -1,0
mecanismo falho de recursão -1,5
apenas caso base: lista vazia +0,5
confunde conteúdo com nó inteiro -1,0
código impuro (do, return) -1,0
perde parte da árvore -0,5 a -1,0
faltaram/sobraram de parênteses -0,5
faltou caso: igual à raiz -0,5
faltou inserir conteúdo -0,5
faltou Node -0,5
achou que Node é lista -0,5
achou que Node tem argumentos entre chaves -0,5
usou New (não existe) -0,5
usou Tree(s) (não existe) -0,5
usou t.val, etc. (não existe) -0,5
inicial maiúscula/minúscula -0,5
dupla inserção -0,5
erro em assinatura -0,5
erro em caso base -0,5
vírgulas a mais -0,5
sintaxe -0,5
apenas caso base +0,5
apenas busca +0,5
nada aproveitável +0,0
faltou função importante: até -1,5
loop infinito -1,0
estratégia ruim -1,0
código impuro -1,0
elemento em lugar de lista ou vice-versa -0,5
< em lugar de =< -0,5
sequências às vezes decrescem -0,5
sobraram ou faltaram parênteses -0,5
sintaxe -0,5
não funciona para k negativo -0,5
faltou caso base em função recursiva -0,5
faltou import -0,5
erro em número de argumentos -0,5
erro em assinatura -0,5
inverteu args de ":" -0,5
list comprehension não feita adequadamente -0,5
confusão em nomes de variáveis -0,5
ordem de guardas -0,5
faltou partição unitária -0,5
map a mais -0,5
repetiu nome de função -0,3
";" em lugar de "++" ou vice-versa -0,2
!= em lugar de /= -0,1
faltou = -0,1
ideia boa de geração +1,0
ideia de geração mal realizada +0,5
apenas verificação ou ideia de verificação +0,5
apenas caso k > n +0,5
apenas verifica soma +0,1
© 2017 João Meidanis