MC336 - Prova Lisp

Enunciado distribuído na sala.

Gabarito

Questão 1

cons
list
append
cons
list

Questão 2

(defun pula (lista)
  (if (null lista)
    nil
    (cons (car lista) (pula (cddr lista)))
  )
)

Questão 3

(defun caixas (expr)
  (if (consp expr)
    (+ 1 (caixas (car expr)) (caixas (cdr expr)))
    0
  )
)

(defun caixas (expr)
  (if (atom expr)
    0
    (+ 1 (caixas (car expr)) (caixas (cdr expr)))
  )
)

Questão 4

(defun poly-add (p1 p2)
  (tira-zeros-final (poly-add-simples p1 p2))
)

;;; a funcao poly-add-simples simplesmente soma as listas
;;; componente a componente; se uma delas acabar, soma soh a outra

(defun poly-add-simples (p1 p2)
  (cond
    ((null p1) p2)
    ((null p2) p1)
    (t (cons (+ (car p1) (car p2))
             (poly-add-simples (cdr p1) (cdr p2))
    )
  )
)

;;; a funcao tira-zeros-final recebe uma lista e retorna a
;;; mesma lista mas com os zeros no final (se houver) removidos

(defun tira-zeros-final (lista)
  (reverse (tira-zeros-inicio (reverse lista)))
)

;;; a funcao tira-zeros-inicio eh similar a tira-zeros-final,
;;; soh que age no inicio da lista

(defun tira-zeros-inicio (lista)
  (cond
    ((null lista) nil)
    ((= 0 (car lista)) (tira-zeros-inicio (cdr lista)))
    (t lista)
  )
)

Critérios de correção

Exceto pela Questão 1, 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. Embora em geral a correção de cima para baixo resulte em notas maiores numa questão, é possível ter exceções a esta tendência.

Nas questões de escrita de código Lisp, os seguintes critérios foram universalmente aplicados:

Critérios de cima para baixo:

• Erro na condição de parada: -0,5
• Esqueceu parênteses ou colocou parênteses no lugar errado: -0,5
• Tratou Lisp como linguagem imperativa: critério de baixo para cima
• Não documentou função auxiliar: -0,5
• Usou mas não definiu função auxiliar: -1,0 se for complexa, -0,5 se for simples.
• Usou função pré-definida errada (por exemplo, append em vez de cons, cadr em vez de cddr, cons ou listp em vez de consp, etc.): -0,5
• Usou função pré-definida (por exemplo, cons, list, etc.) a mais ou a menos: -0,5

Critérios de baixo para cima:

• 0,5 para cada indício de conhecimento.

A seguir, critérios específicos para cada questão. Nas questões de código, são todos critérios de cima para baixo.

Questão 1

Cada item valeu 0,5.

Questão 2

• Usou nil em vez do nome do parâmetro: -0,5
• Colocou (car lista) em vez de lista: -0,5
• Usou = aritmético para comparar expressões em geral: -0,5
• Não funciona com átomos: -0,5
• Trocou ordem dos argumentos de cons: -0,5
• Usou % para indicar mod: -0,5
• Usou a função last de forma errada: -0,5
• Contou a paridade começando pelo final da lista: -0,5

Questão 3

• Esqueceu de chamar recursivamente: -1,0
• Usou null ou (= (car L) 0) em vez de atom: -0,5
• Somou demais ou somou errado no acumulador: -0,5
• Usou caixas em lugar do parâmetro: -0,5
• Retornou 0 se o cdr era nulo: -0,5
• Retornou 1 para átomos: -0,5
• Usou quote onde não deveria: -0,5

Questão 4

• Não se preocupou em tirar os zeros do final: -1,0
• Tentou tirar os zeros do final, mas não funciona sempre: -0,5
• Testou nulo em vez de zero: -0,5
• Usou acumulador e esqueceu de reverter o resultado: -0,5
• Retornou zero ou nil se os argumentos eram iguais: -0,5
• Não somou último termo: -0,5
• Verificou entrada (não precisava): perdoado

MC336 Home

© 2013 João Meidanis