© E.L.

Favero Algoritmos em Python 88

Capítulo
12 FUNÇÕES RECURSIVAS
Apresentamos problemas e funções recursivas. Como extra, da cultura do pensamento
computacional, falamos sobre paradigmas de programação e jeito pythônico de codificação.

12.1 Função reverse() e palíndromo()

A função reverse, reverter a lista, tem várias aplicações. Uma delas é no código da função
palíndromo. Uma lista é um palíndromo se ela for igual a sua imagem invertida, assim
list("abcba") é palíndromo, pois list("abcba") =rev(list("abcba") ).

lista= ['a', 'b', 'c', 'b', 'a' ]

índice -1 0 1 2 3 4

Uma forma simples de inverter uma lista é pela manipulação de fatias, assim
reverso(x) = x[::-1]. Mas vamos programar outras formas para exercitar a solução do
problema:
i) rev: iniciar no índice len()-1, até 0, diminuindo de 1; fica range(len(s)-1,-1,-1);
ii) rev1: percorrer a lista com for tirando do inicio da lista e colocando no final;
iii)rev2: idem com recursividade, sem o for.

def rev(s):
REV=[]
for i in range(len(s)-1,-1,-1):
REV.append(s[i])
return REV
print('rev abcdef:',*rev(list('abcdef')))
>>>
rev abcdef: f e d c b a

Abaixo com o Python tutor vemos a lista REV sendo construída na forma reversa. Passo a
passo os elementos de trás -1 para frente (com passo -1) são copiados para a nova lista,
REV.
© E.L.Favero Algoritmos em Python 89

O append sempre acrescenta um elemento no final da lista. Mas o + é mais flexível podendo
concatenar quaisquer duas listas, assim podemos percorrer a lista do início para o fim e
sempre ir acrescentando na frente da nova lista REV sendo formada. O + concatena duas
lista portanto o elemento s[i] é colocado dentro de uma lista [s[i]].

def rev1(s):
REV=[]
for i in range(len(s)):REV=[s[i]]+REV
return REV

12.2 Funções recursivas

Outro recurso poderoso de programação são as funções recursivas. Vamos apresentar o
conceito com a função reverse.

def rev2(s):
if s!=[]: return rev2(s[1:])+[s[0]] # recursividade
else: return [] # base: fim

Uma função é recursiva se ela se chama a si mesma: na linha do def, ela é definda, e
dentro do seu corpo, ela já é chamada antes de termos terminado sua definição. Dentro do
corpo: uma linha ela se chama recursivamente (caso recursivo) e na outra linha ela termina
a recusividade (caso base).
Abaixo no Python Tutor vemos que primeiro a função vai se chamando e a lista de
entrada diminui até ficar vazia. As funções recursivas vão se empilhando dentro da máquina
abstrata de execução do Python. Depois de chegar no vazio da lista da entrada, as funções
vão gerando o retorno, com as listas parciais invertidas.
© E.L.Favero Algoritmos em Python 90

Com mais dois passos next, vemos o retorno da lista parcial [c,d] invertida, agora [d,c].
Continuando com next as funções são removidas da pilha de execução e o resultado vem
sendo montado, até se chegar em [d,c,b,a]. Para animar funções recursivas no Python Tutor
utilize entradas pequenas de no máximo 5 elementos.

Abaixo temos um teste comparando as três versões de reverse, para mostar que elas geram
o mesmo resultado.

li=list("123456")
print('rev:', *rev(li), 'rev1:', *rev1(li),'rev2:', *rev2(li)
>>>
rev: 6 5 4 3 2 1 rev1: 6 5 4 3 2 1 rev2: 6 5 4 3 2 1
© E.L.Favero Algoritmos em Python 91

Agora que temos várias versões de reverse vamos programar duas versões da função
palíndromo, a primeira mais fácil de ler, x==rev(x) e a segunda um pouco mais abstrata
x==x[::-1].

def palídromo(x): return x==rev(x)

def palídromo1(x):return x==x[::-1]

print(palídromo(list('abcdeedcba')))
print(palídromo(list('12321')))
print(palídromo1(list('12321')))
print(palídromo1(list('123X21')))
>>>
True
True
True
False

12.3 Problemas recursivos

O que faz uma função recursiva? Porque utilizar funções recursivas? No exemplo de
reverse, a recursividade substitui o comando de repetição. Mas, na matemática é comum o
uso de funções recursivas para tratar de problemas com definições recursivas. Neste caso,
a recursividade da linguagem de programação permite uma codificação direta da função
matemática com a função a ser programada.

As folhas da Bromélia são formadas por espirais, cujos raios pertencem a série de
Fibonacci. Esta série foi descoberta pelo matemático Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,
... Ele mostrou a série com o exemplo do crescimento acelerado da população de coelhos,
com a fórmula recursiva:

Fo= 0, F1 = 1 # Caso base

Fn = Fn - 1 + Fn – 2 # Caso recursivo

Segue o programa recursivo que codifica esta série. São dois casos na fórmulas, então
temos um comando if para decidir qual dos casos será executado a partir do valor de n;
caso base ou caso recursivo. No teste abaixo com n=3, o terceiro elemento da série é 2 e o
sexto elemento é o 8.
© E.L.Favero Algoritmos em Python 92

def fibo(n):
if n<=1: return n # base: fim
else: return fibo(n-1)+fibo(n-2) # recursividade
print(fibo(3))
print(fibo(6))
for i in range(0,10): print(fibo(i),end=' ')
>>>
2
8
0 1 1 2 3 5 8 13 21 34

Abaixo com o Python tutor podemos ver as várias chamadas de fibo() até termos um
primeiro retorno para fibo(1). Com next e prev podemos navegar sobre a execução das
chamadas recursivas, para compreender melhor como ocorre a recursão.
 © E.L.Favero Algoritmos em Python 93

12.4 Exercícios (7)

Ao responder estes exercícios, teste cada função com duas entradas para garantir
que a saída está correta.

E12.1 Faça a função reverse usando um for e range: iniciar no índice len()-1, até 0,
diminuindo de 1; fica range(len(s)-1,-1,-1)
def rev(s):
REV=[]
for i in range(len(s)-1,-1,-1):
REV.append(s[i])
return REV
print('rev abcdef:',rev(list('abcdef')))

E12.2 Faça a função reverse: percorrer a lista do início para o fim com for e sempre ir
acrescentando na frente da nova lista REV sendo formada, use o + para concatenar
na frente de REV.

E12.3 Faça a função reverse com a estratégia da questão anterior, substituindo o for por
recursividade: percorrer a lista do início para o fim e sempre ir acrescentando na
frente da nova lista REV sendo formada, use o + para concatenar

E12.4 Faça a função palídromo usando x[::-1] para inverter x

def palídromo1(x):return x==x[::-1]
print(palídromo1(list('12321')))
print(palídromo1(list('123X21')))

E12.5 Faça a função palídromo usando rev()

E12.6 Faça a função palídromo sem usar uma lista invertida. Comparando sempre os dois
extremos, em direção ao meio. Use índices para fazer as comparações.

E12.7 Faça a função fatorial usando recursividade:

i) Caso base: fatorial(n) se n<=1 é 1
ii) Caso recursivo: fatorial(n) se n>1 é igual a fatorial(n-1)*n

12.4.1 Perguntas conceituais (2)

Responda com no mínimo 10 palavras e no máximo 20 palavras:
C12.1 O que caracteriza uma função recursiva?
C12.2 Numa função recursiva, qual a diferença entre o caso base e o caso recursivo?