Baixe Fundamentos da Programação: Recursão e Recursividade em Python e outras Resumos em PDF para Matérias técnicas, somente na Docsity!
Fundamentos da Programação
LEIC/LETI
Recursão
Recursividade. Recursão de cauda
Aula 21
Alberto Abad, Tagus Park, IST, 2021-
Funções revisitadas
Programação Funcional
Programação imperativa : programa como conjunto de instruções em que a instrução de atribuição tem um papel preponderante. A Programação funcional é um paradigma de programação exclusivamente baseado na utilização de funções: Funções calculam ou avaliam outras funções e retornam um valor/resultado, evitando alterações de estado e entidades mutáveis. Não existe o conceito de atribuição e não existem ciclos. O conceito de iteração é conseguido através de recursividade.
Funções revisitadas
Elementos da Programação Funcional
Na informática, diz-se que uma linguagem de programação tem funções de primeira classe ( first- class functions ) se a liguagem suporta utilizar funções como argumentos para outras funções, retornar funções como valor de outras funções, atribuir funções a variáveis, ou armazenar funções em estruturas de dados. O Python, tem funções de primeira classe o que nos fornece alguns dois elementos fundamentais dada programação funcional: Funções internas (ontem) Recursão (hoje e o resto da semana) Funções de ordem superior: (a próxima semana) Funções como parâmetros Funções como valor
Funções revisitadas
Funções recursivas
Uma solução recursiva para um problema depende da combinação de soluções para instâncias mais pequenas desse mesmo problema. Uma dada entidade é recursiva se ela for definida em termos de si própria. Python, tal como a maioria das linguagens de programação, suporta explicitamente soluções recursivas permitindo que as funções possam invocar-se a si mesmas. Em programação funcional e em linguagens puramente funcionais, estamos limitados ao uso de funções recursivas, não sendo possível o uso de ciclos iterativos.
In [24]: #^ solucao^ iterativa def potencia_it(x, k): pot = 1 while k > 0 : pot = pot * x k -= 1 return pot def potencia_rec(x, k): # Caso terminal if k == 0 : return 1 # Caso geral elif k > 0 : return x*potencia_rec(x, k- 1 ) else : return potencia_rec(x, k+ 1 )/x potencia_rec( 2 , 50 )
Funções revisitadas
Funções recursivas. Exemplo 1, potencia. Python
Tutor
http://pythontutor.com/visualize.html (http://pythontutor.com/visualize.html) Out[24]: (^1125899906842624)
Funções revisitadas
Mais exemplos de funções recursivas
Soma de digitos Factorial Progressão aritmetica Maximo divisor comum Alisa
Funções revisitadas
Funções recursivas. Exemplo 2, soma_digitos de um
inteiro
In [25]: def soma_digitos(num): soma = 0 while num!= 0 : soma += num % 10 num = num // 10 return soma def soma_digitos_rec(n): # return n if n < 10 else n%10 + soma_digitos_rec(n//10) if n < 10 : return n else : return n% 10 + soma_digitos_rec(n//10) soma_digitos_rec( 56071 )
Funções revisitadas
Funções recursivas. Exemplo 2, soma_digitos de um
string
Out[25]: (^19)
Funções revisitadas
Funções recursivas. Exemplo 4, soma progressão
aritmética
In [28]: def soma(n): res = 0 for i in range( 1 ,n+ 1 ): res += i return res def soma_rec(n): if n == 0 : return 0 else : return n+soma_rec(n- 1 ) soma_rec( 10 )
Funções
Funções recursivas. Exemplo 5, Máximo divisor
comum
- O máximo divisor comum entre um número e zero é o próprio número: mdc(m,0) = m
- Quando dividimos um número m por um menor n , o máximo divisor comum entre o resto da divisão e o divisor é o mesmo que o máximo divisor comum entre o dividendo e o divisor: mdc(m, n) = mdc(n, m%n) def mdc(m,n): while n != 0 : m, n = n, m % n return m Out[28]: (^55)
In [29]: def^ mdc(m,n): while n != 0 : m, n = n, m % n return m def mdc_rec(m, n): if n == 0 : return m else : return mdc_rec(n, m% n ) mdc_rec( 12 , 8 )
Funções
Funções recursivas. Exemplo 6, Função alisa
In [30]: def^ alisa(t): i = 0 while i < len(t): if isinstance(t[i], tuple): t = t[:i] + t[i] + t[i+ 1 :] else : i = i + 1 return t def alisa_rec(t): if t == (): return () else : if isinstance(t[ 0 ], tuple): return alisa_rec(t[ 0 ]) + alisa_rec(t[ 1 :]) else : return (t[ 0 ],) + alisa_rec(t[ 1 :]) a = ( 2 , 4 , ( 8 , ( 9 , ( 7 , ), 3 , 4 ), 7 ), 6 , ( 5 , ( 7 , ( 8 , )))) alisa_rec(a) Out[29]: (^4) Out[30]: (2, 4, 8, 9, 7, 3, 4, 7, 6, 5, 7, 8)
Tarefas próxima aula
Estudar matéria e completar exemplos Ler seções 7.3 do livro (recursão de cauda) WARNING: O deadline para entrega do projeto 1 é esta sexta-feira dia 5 de Novembro até ás 17h00!! In [ ]:
