Escola Superior de Tecnologia

Instituto Politécnico de Castelo Branco

Aulas Práticas de
Fundamentos de Inteligência Artificial

Arlindo Silva
Ana Paula Neves
 Aula

4
Soluções dos Exercícios
Recursividade em Listas Simples e Imbricadas
Resolução dos Exercícios do Texto

Seguindo a estrutura descrita acima implemente as seguintes funções de forma recursiva:

1. my-remove que recebe uma lista e um elemento e devolve uma nova lista onde foi removido o
elemento.

2. my-length que recebe uma lista e devolve o tamanho da lista.

(defun my-remove1 (x l)
(if (null l)
nil
(if (equal x (first l))
(copy-list (rest l))
(cons (first l) (my-remove1 x (rest l))))))

> (my-remove1 'b '(a b a b a))

(A A B A)

(defun my-length (l)

(if (null l)
0
(+ 1 (my-length (rest l)))))

> (my-length '(a b a b a))

5

1. Redefina a função pot de maneira a que a função consiga manipular expoentes negativos (deve
continuar a ser uma função recursiva).

2. Defina recursivamente uma função my-remove que remova todas as ocorrências de

um elemento numa lista. Por exemplo:
> (my-remove 'a '(a b a c a))
(B C)
(defun potencia1 (x y)
(if (= y 0)
1.0
(if (> y 0)
(* (potencia1 x (- y 1)) x)
(/ (potencia1 x (+ y 1)) x))))

> (potencia1 2 -2)

0.25
> (potencia1 2 2)
4.0

(defun my-remove2 (x l)
(if (null l)
nil
(if (equal x (first l))
(my-remove2 x (rest l))
(cons (first l) (my-remove2 x (rest l))))))

> (my-remove2 'b '(a b a b a))

(A A A)

1. Implemente uma função recursiva encontra que devolva t se encontrar um átomo que recebe
como parâmetro, numa lista imbricada. Por exemplo:

> (encontra ‘a ‘(c d (a b) e))

(defun encontra (x l)
(if (null l)
nil
(if (equal x (first l))
t
(or
(if (listp (first l))
(encontra x (first l)))
(encontra x (rest l))))))

> (encontra 'a '(a (b c) d (e (f))))

T
> (encontra 'b '(a (b c) d (e (f))))
T
> (encontra 'f '(a (b c) d (e (f))))
T
> (encontra 'g '(a (b c) d (e (f))))
NIL

2
Resolução dos Exercícios Finais

1. Uma palavra palíndrome é uma palavra cuja leitura da esquerda para a direita é igual à leitura da
direita para a esquerda. A função a baixo verifica se a lista que recebe como argumento é um
palíndrome.

(defun palindromep (lst)

(equal lst (reverse lst)) )

Assim, por exemplo:

>(palindromep '(1 2 3 4 5 4 3 2 1))

T

>(palindromep '(a b b a))

T

>(palindromep '(1 2 3))

NIL

Escreva uma versão recursiva da função palindromep e chame-lhe r-palindromep. Não

deve fazer uso da função reverse.

(defun palindromep (lst)

(if (or (null lst) (equal (length lst) 1))
t
(if (equal (first lst) (first (last lst)))
(palindromep (butlast (rest lst))))))

> (palindromep '(a b b a))

T

> (palindromep '(a b r a))

NIL

2. Uma expressão matemática em Lisp tem uma apresentação semelhante a:

(+ (* 1 2 pi) 3 (- 4 5))

Para a maioria das pessoas a leitura da expressão seria facilitada caso fosse utilizada uma notação
infix:

((1 * 2 * pi) + 3 + (4 - 5))

3
 Escreva uma função infix que receba expressões matemáticas no formato do Lisp e que retorne a
versão correspondente no formato infix.

(defun infix (l)

(cond
((atom l) l)
((null l) nil)
((= (length l) 1) l)
((= (length l) 2) (list (infix (second l))))
(t (cons (infix (second l))
(cons (first l)
(infix (cons (first l)
(rest (rest l)))))))))

> (infix '(+ (* 1 2 pi (+ 3 4)) 3 (- 4 5)))

((1 * 2 * PI * (3 + 4)) + 3 + (4 - 5))

3. Escreva uma função my-replace a qual deve receber uma lista e dois elementos como
argumentos e que retorne uma lista a qual deve resultar da substituição de todas as ocorrências do
primeiro elemento pelo segundo na lista argumento.

(defun my-replace (lst n1 n2)

(if (null lst)
nil
(if (equal (first lst) n1)
(cons n2 (my-replace (rest lst) n1 n2))
(cons (first lst) (my-replace (rest lst) n1 n2)))))

> (my-replace '(a b b a) 'b 'c)

(A C C A)

4. Escreva uma função conta_atomos que conte todos os elementos átomos de uma lista
imbricada que recebe como argumento.

(defun conta_atomos (lst)

(if (null lst)
0
(if (atom (first lst))
(+ 1 (conta_atomos (rest lst)))
(if (listp (first lst))
(+ (conta_atomos (first lst))
(conta_atomos (rest lst)))
(conta_atomos (rest lst))))))

4
> (conta_atomos '(a (b c) d (e (f))))
6

5. Escreva uma função insere que deve receber como argumento uma lista e dois átomos e
retorne uma lista que deve resultar da inserção do segundo átomo à direita de todas as ocorrências do
primeiro átomo na lista argumento.

(defun insere (lst n1 n2)

(if (null lst)
nil
(if (equal (first lst) n1)
(cons (first lst) (cons n2 (insere (rest lst) n1 n2)))
(cons (first lst) (insere (rest lst) n1 n2)))))

> (insere '(a c a c) 'a 'b)

(A B C A B C)

6. Escreva uma função my-merge que deve receber duas listas de números de igual tamanho. A
função deverá somar os números correspondentes de cada uma das listas e retornar o produto dos
resultados de todas as somas. Por exemplo, (merge ‘(1 2 3) ‘(2 2 2)) deverá retornar
60, dado que (1 + 2) *(2 + 2) * (3 + 2) = 60.

(defun merge1 (lst1 lst2)

(if (and (null lst1) (null lst2))
1
(* (+ (first lst1) (first lst2))
(merge1 (rest lst1) (rest lst2)))))

> (merge1 '(1 2 3) '(2 2 2))

60

7. A série de Finonacci é definida da seguinte forma:

fib(n) = {fib(n-1) + fib(n-2) Se n>1}

{1 Se n=0 or n=1}

Implemente uma função recursiva que permita calcular o nth número de Fibonacci.

(defun fibonacci (n)

(if (or (= n 0) (= n 1))
1
(+ (fibonacci (- n 1)) (fibonacci (- n 2)))))

> (fibonacci 5)
8

5
 8. Será que a função seguinte termina sempre? (Deverá considerar todos os casos).

(defun mystery (n)

(cond ((= n 0) 0)
(t (mystery (- n 1)))))

Se n for um úmero negativo a função não termina.

> (mystery -4)

;; Error: Stack overflow. You may be recursing infinitely.