MC600 - Segundo semestre de 2003 - LISTA 3
------------------------------------------


1. Dada a seguinte definição:

  (setf mylist '((fhc frango)(collor tereza)
          (voce nao eh a mamae)
          (e por favor)(spielberg (toni ramos))
          (polvo lula mariscos)))

Construa as listas abaixo usando qualquer função que você 
tenha aprendido até agora.

a. (frango nao por favor)
b. ((tereza collor) nao eh a mamae)
c. (collor fhc lula)
d. (spielberg nao eh a favor)

Respostas:

a. (frango nao por favor)

(list (car (cdr (car mylist)))
      (car (cdr (car (cdr (cdr mylist)))))
      (car (cdr (car (cdr (cdr (cdr mylist))))))
      (car (cdr (cdr (car (cdr (cdr (cdr mylist))))))))

b. ((tereza collor) nao eh mamae)

(cons (list (car (cdr (car (cdr mylist))))
	    (car (car (cdr mylist))))
      (cdr (car (cdr (cdr mylist)))))

c. (collor fhc lula)

(list (car (car (cdr mylist)))
      (car (car mylist))
      (car (cdr (car (cdr (cdr (cdr (cdr (cdr mylist)))))))))

d. (spielberg nao eh a favor)

(list (car (car (cdr (cdr (cdr (cdr mylist)))))) 
      (car (cdr (car (cdr (cdr mylist)))))
      (car (cdr (cdr (car (cdr (cdr mylist))))))
      (car (cdr (cdr (cdr (car (cdr (cdr mylist)))))))
      (car (cdr (cdr (car (cdr (cdr (cdr mylist))))))))


2.  Escreva uma função "unnest", que recebe uma única 
lista como parâmetro e retorna uma lista simples contendo 
todos os seus átomos:

Ex. (unnest '(1 (2 (3))(4 5)) ) ==> (1 2 3 4 5)
    (unnest '(((((teste))))) ) ==> (teste)

Resposta:

(defun unnest (lst)
    ( if (null lst)
        nil
        ( let (( obj (car lst)))
            ( if (null obj)
                (unnest (cdr lst))
                ( if (lstp obj)
                    (append (unnest obj) (unnest (cdr lst)))
                    (cons obj (unnest (cdr lst)))
                )
            )
        )
    )
)


3. Considere a seguinte definição:

  (defun life (a b)
     (cond ((null a) b)
        ((null b) a)
        (t 'its-tough)))

Suponha que você está executando um interpretador LISP e 
que você digite o seguinte:

>(setf a 'oh-boy)

Depois você faz o seguinte:

>(life 'gummi a)

Quais são os valores globais e locais de "a" e "b" antes, 
durante e depois da execução deste comando?

Resposta:

Antes da Execução do comando:

Global             Local
a = oh-boy        Não Existe
b = indefinido    Não Existe

Durante a execução do comando:

Global             Local
a = oh-boy        gummi
b = indefinido    oh-boy

Depois da Execução do comando:

Global             Local
a = oh-boy        Não Existe
b = indefinido    Não Existe


4. Escreva uma função REVERSO, que inverte os elementos 
de uma lista.

Ex. (reverso '(A (B C) D (E F)) ) ==> ((E F) D (B C) A)

Resposta:

(defun reverso (lst)
   (reverso1 (lst nil))
)

(defun reverso1 (lst lst2)
   (if (null lst)
      lst2
      (reverso1 ((cdr lst) (cons ((car lst) lst2))))
   )
)


5. Escreva uma função REVERSO-TOTAL, que inverte os 
elementos de uma lista e inverta também, recursivamente,
os elementos das listas contidas dentro da primeira.

Ex. (reverso-total '(A (B C) D (E F)) ) ==> ((F E) D (C B) A)

Resposta:

(defun revtot1 (lst lst2)
  (if (null lst)
      lst2
    (if (listp (car lst))
      (revtot1 (cdr lst) (cons (revtot (car lst)) lst2))
      (revtot1 (cdr lst) (cons (car lst) lst2))
    )
  )
)

(defun revtot (lst)
  (revtot1 lst nil))