Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

4 - Recursividad

No description
by

Jose Daniel Chacón Bogarín

on 7 February 2014

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of 4 - Recursividad

Recursividad
Base para repetición de acciones.
Alternativa a la iteración (uso de ciclos) basada en que la función resuelve el problema en términos de sí misma.
Ejemplo
Sumar dígitos de un número entero.
>>> suma_dig(1004) >>> suma_dig(43675865) >>> suma_dig(3)
5 44 3
Es descomponer un problema en uno pequeño que se repetirá hasta que se cumpla una determinada condición.
E: número entero.
S: suma de los dígitos.
R: número entero.
Ver 1:
def

suma_dig
(num):
if
num == 0:
return
0
else
:
return
num%10 + suma_dig(num//10)
Prueba Manual
>>> suma_dig(43586)
6 + suma_dig(4358)
6 + 8 + suma_dig(435)
6 + 8 + 5 + suma_dig(43)
6 + 8 + 5 + 3 + suma_dig(4)
6 + 8 + 5 + 3 + 4 + suma_dig(0)
6 + 8 + 5 + 3 + 4 + 0
6 + 8 + 5 + 3 + 4
6 + 8 + 5 + 7
6 + 8 + 12
6 + 20
26
¿Cuál es el problema?
Versión 1.5
def

suma_dig
(num):
if
isinstance

(num,
int
):
if

num == 0:
return

0
else
:
return

num%10 + suma_dig(num//10)
else
:
return
'Error'
Hace la pregunta por
cada dígito. (Ineficiente)
Versión 2
Es mejor hacer una
función no recursiva
que verifique las restricciones y luego llame a la recursiva.
Composición de funciones. La salida de una función es la entrada de la otra.
Tipos de recursividad
Pila
La llamada recursiva es parte de una operación.
La ejecución forma una pila de operaciones que se evalúan hasta llegar a la condición de parada.

Ejemplo
Contar dígitos de un número entero.
>>> largo(123151) >>> largo(0)
6 1
def
largo
(num):
if

isinstance
(num, int):
if
num != 0:
return
largo_aux(
abs
(num))
else
:
return
1
else
:
return

'Error'
def
largo_aux
(num):
if
num == 0:
return
0
else
:
return
1 + largo_aux(num // 10)
Función Principal
Función Auxiliar
Condición de parada
Valor de retorno
Llamada recursiva
Operación a apilar
Corrida Manual
>>> largo(73157)
largo_aux(73157)
1 + largo_aux(7315)
1 + 1 + largo_aux(731)
1 + 1 + 1 + largo_aux(73)
1 + 1 + 1 + 1 + largo_aux(7)
1 + 1 + 1 + 1 + 1 + largo_aux(0)
1 + 1 + 1 + 1 + 1 + 0
1 + 1 + 1 + 1 + 1
1 + 1 + 1 + 2
1 + 1 + 3
1 + 4
5
Reglas para escribir una función recursiva
Si hay casos especiales y/o restricciones generales, usar (por eficiencia) un esquema de la función principal y función auxiliar recursiva.
Definir el o los casos base, o sea cuándo se va a terminar. En cada caso base definir el valor de retorno. Por ejemplo: en recursividad de pila, normalmente el valor de retorno va a ser el elemento neutro de la operación a realizar.
Definir si es necesario (por ejemplo para recursividad de pila) la operación a realizar.
Plantear la llamada recursiva, haciendo que el o los argumentos necesarios tiendan al caso base, o sea que se asegura que va a teminar.
Ejercicio
Hacer una función que reciba un número entero e indique si el número tiene al menos un 0.
Hacer una función "iguales" que indique si el primer y último dígito de un número son iguales.
Solución
E: Número.
S: Indicador booleano.
R: Número debe ser entero.
def

primer_digito
(num):
if
num < 10:
return
num
else
:
return
primer_digito(num//10)
def

iguales
(num):
if

isinstance
(num,
int
):
return
num%10==primer_digito(num)
else
:
return
"Error"
Hacer una función "revise" que indique cuántos dígitos están entre entre 5 y 9 y cuántos están entre 0 y 4.
Solución 1
E: Número.
S: Tupla conteniendo cantidad de dígitos entre 5 y 9, y entre 0 y 4.
R: Número debe ser entero.
def

revise
(num):
if

isinstance
(num,
int
):
return
entre0y4(num), entre5y9(num)
else
:
return

"Error"
def

entre0y4
(num):
if
num == 0:
return
0
elif
num %10 < 5:
return
1+entre0y4(num//10)
else
:
return
entre0y4(num//10)
def

entre5y9
(num):
if
num == 0:
return
0
elif
num %10 > 4:
return
1+entre5y9(num//10)
else
:
return
entre5y9(num//10)
Solución 2
E: Número.
S: Tupla conteniendo cantidad de dígitos entre 5 y 9, y entre 0 y 4.
R: Número debe ser entero.
def

revise
(num):
if

isinstance
(num,
int
):
return
entre0y4(num), largo(num) - entre0y4(num)
else
:
return

"Error"
def

entre0y4
(num):
if
num == 0:
return
0
elif
num %10 < 5:
return
1+entre0y4(num//10)
else
:
return
entre0y4(num//10)
Solución 3
E: Número.
S: Tupla conteniendo cantidad de dígitos entre 5 y 9, y entre 0 y 4.
R: Número debe ser entero.
def

revise
(num):
if

isinstance
(num,
int
):
e0y4 = entre0y4(num)
return
e0y4, largo(num) - e0y4
else
:
return

"Error"
def

entre0y4
(num):
if
num == 0:
return
0
elif
num %10 < 5:
return
1+entre0y4(num//10)
else
:
return
entre0y4(num//10)
Función lambda
Son funciones pequeñas.
Normales en lenguajes funcionales.

Forma general:
variable = lambda arg1, arg2,...argn: operación

Ejemplo:
>>> cubo = lambda num: num**3
>>> cuadrado = lambda num: num**2
>>> cubo(3) >>> cuadrado(8)
27 64
Funciones como argumentos
Python puede usar el nombre de una función como argumento de otra.

Forma general:
def

opere
(num, funcion):
return
funcion(num)

Ejemplos:
>>> opere(3, cubo)
27
>>> opere(-14,
abs
)
14
También acepta funciones
generales de Python
Solución 4
E: Número.
S: Tupla conteniendo cantidad de dígitos entre 5 y 9, y entre 0 y 4.
R: Número debe ser entero.
def

revise
(num):
if

isinstance
(num,
int
):
menor5 =
lambda
n: n<5
mayor4 =
lambda
n: n>4
return
revise_aux(num, menor5), revise_aux(num, mayor4)
else
:
return

"Error"
def

revise_aux
(num, condicion):
if
num == 0:
return
0
elif
condicion(num%10):
return
1+revise_aux(num//10, condicion)
else
:
return
revise_aux(num//10, condicion)
¡Ineficiente!
Un poco más eficiente
Hacer una función "forme_par" que reciba un número entero y forme otro número con los dígitos pares.
>>> forme_par(584123)
842
Solución
584123
3 no es par
2 es par
1 no es par
4 es par
8 es par
5 es impar
2*10**0 = 2
4*10**1 = 40
8*10**2 = 800
842
def

forme_par
(num):
if

isinstance
(num,
int
):
return
forme_par_aux(num, 0)
else
:
return

"Error"
def

forme_par_aux
(num, exp):
if
num == 0:
return
0
elif
num % 2 == 0:
return
num % 10 * 10 ** exp + forme_par_aux(num//10, exp+1)
else
:
return
forme_par_aux(num//10, exp)
Factorial
Factorial de un número:
0! = 1 -> Caso Base
.
.
.
n! -> n*(n-1)! -> Fórmula General
Ej: 5!
5! = 5 * 4!
= 5 * 4 * 3!
= 5 * 4 * 3 * 2!
= 5 * 4 * 3 * 2 * 1!
= 5 * 4 * 3 * 2 * 1 * 0!
= 5 * 4 * 3 * 2 * 1 * 1
= 120
E: n
S: n!
R: n entero >= 0

def

factorial
(n):
if

isinstance
(n,
int
) and n>=0:
return
factorial_aux(n)
else
:
return

"Error"

def

factorial_aux
(n):
if
n == 0:
return
1
else
:
return
n * factorial_aux(n-1)
Funciones aritméticas naturalmente recursivas
Fibonacci
Sucesión Fibonacci:
fib(0) = 0
fib(1) = 1
.
.
.
fib(n) = fib(n-1)+fib(n-2)
E: n
S: Fibonacci de n
R: n entero >= 0

def

fibonacci
(n):
if

isinstance
(n,
int
) and n>=0:
return
fib_aux(n)
else
:
return

"Error"

def

fib_aux
(n):
if
n == 0
or
n==1:
return
n
else
:
return
fib_aux(n-1) + fib_aux(n-2)
Recursividad
Doble
fib5
fib3
fib3
fib4
fib1
fib0
fib1
fib2
fib0
fib1
fib1
fib2
fib2
fib1
fib0
Cuente
>>>cuente(2, 1029099)
(1,6)
E: dígito número
S: Tupla formada por:
Dígitos divididos en forma exacta
Dígitos no divididos en forma exacta
R: Dígito válido y número entero.
def
cuente
(dig, num):
if

isinstance
(num,
int
)
and

isinstance
(dig,

int
)
and


dig>=0
and
dig<=9:
esDivisible =
lambda
d, dn: dn%d==0
noDivisible =
lambda
d, db: dn%d!=0
num =
abs
(num)
return
cuente_aux(dig,num,esDivisible),
cuente_aux(dig, num, noDivisible)
else
:
return
"Error."
def
cuente_aux
(dig, num, condicion):
if
num==0:
return
0
elif
condicion(dig, num%10):
return
1+ cuente_aux(dig, num//10, condicion)
else
:
return
cuente_aux(dig, num//10, condicion)
>>>cuente(2,4326)
cuente_aux(2,4326, dn%d==0)
1+cuente_aux(2,432,dn%d==0)
1+cuente_aux(2,43,dn%d==0)
1+1+cuente_aux(2,4,dn%d==0)
1+1+1+cuente_aux(2,0,dn%d==0)
1+1+1+0
1+1+1
1+2
3, cuente_aux(2,4326,dn%d!=0)
3, cuente_aux(2,432,dn%d!=0)
3, cuente_aux(2,43,dn%d!=0)
3, 1+cuente_aux(2,4,dn%d!=0)
3, 1+cuente_aux(2,0,dn%d!=0)
3, 1+0
(3,1)
Corrida Manual
Regla 1
Regla 2
Regla 3
Regla 4
Cola
Solución
E: Número.
S: Indicador booleano.
R: Número debe ser entero.
def

tiene_cero_aux
(num):
if
num == 0:
return False
elif
num % 10 == 0:
return True
else
:
return
tiene_cero_aux(num//10)
def

tiene_cero
(num):
if

isinstance
(num,
int
):
return
tiene_cero_aux(num)
else
:
return

"Error"
Recursividad Sobre Secuencias
Secuencias: colecciones de elementos que pueden ser accesados por un índice.
Tipos:
Mutables: pueden ser cambiadas a nivel de elementos. Las más utilizadas son las listas.
Inmutables: no pueden ser cambiadas a nivel de sus posiciones. Las principales son los strings y las tuplas.

Listas
Elementos entre "[]", separadas por coma.
>>>lista = [1,3,5,9]
Son heterogéneas, es decir pueden tener diferentes tipos de datos dentro de ellas.
>>>lista = [4, "hola", 5.0, [3]]
Lista nula: []
Mutabilidad Listas E Índices
>>>lista = [1,3,5,9]
lista[2] = 20
>>>lista
[1,3,20,9]
>>>lista[4] = 10
Error índice
Strings
Colecciones de elementos entre comillas.
>>>tira =
"Esta es una tira de caracteres"
>>>tira[5] = "E"
Error inmutabilidad.
String nulo: "" o '' -> ¡Sin espacio!
Tuplas
Colecciones de elementos entre paréntesis redondos.
>>>tupla = (1,3,5,9)
>>>tupla[5] =
"E"
Error inmutabilidad.
Una tupla nula: ()
Función Len
Retorna la cantidad de elementos de una secuencia.
>>>tira =
"hola"
>>>lista = [1,4]
>>>tupla = (1,3,5,9,13)
>>>
len
(tira)
4
>>>
len
(lista)
2
>>>
len
(tupla)
5
Slicing
Forma diferente de accesar a las posiciones de una secuencia.

s[i:j] -> retorna una secuencia del mismo tipo de la original con las posiciones contenidas entre i y j-1. Los argumentos i, j pueden ser opcionales.

>>>lista = [1,5,7,9,11,13,14]
>>>sublista = lista[1:4]
[5,7,9]
>>>sublista1 = lista[3:]
[9,11,13,14]
>>>sublista2 = lista[:4]
[1,5,7,9]

s[1:] -> quita el primer elemento de la lista. Similar a x//10 de números.
s[0] -> obtiene la primera posición de la lista. Similar a x%10.

Ejemplos
Números
Multiplicar los dígitos de un número entero
E: número
S: multiplicación dígitos
R: número entero

def

multi
(num):
if

isinstance
(num,
int
):
return
multi_aux(num)
else
:
return
'Error'

def

multi_aux
(num):
if
num == 0:
return
1
else
:
return
num%10*multi_aux(num//10)
Multiplicar los dígitos de una lista
E: lista
S: multiplicación dígitos
R: lista no nula

def

multi
(lista):
if

isinstance
(lista,
list
) and lista != []:
return
multi_aux(lista)
else
:
return

'Error'

def

multi_aux
(lista):
if
lista == []:
return
1
else
:
return
lista[0]*multi_aux(lista[1:])
Lista
>>>multi(1462)
multi_aux(1462)
2*multi_aux(146)
2*6*multi_aux(14)
2*6*4*multi_aux(1)
2*6*4*1*multi_aux(0)
48
>>>multi( [1,4,6,2] )
multi_aux( [1,4,6,2] )
1*multi_aux( [4,6,2] )
1*4*multi_aux( [6,2] )
1*4*6*multi_aux( [2] )
1*4*6*2*multi_aux( [] )
48
Multiplicar los dígitos de una lista usando índices
E: lista
S: multiplicación dígitos
R: lista no sea nula

def

multi
(lista):
if

isinstance
(lista,
list
) and lista != []:
return
multi_aux(lista, 0, len(lista))
else
:
return

'Error'

def

multi_aux
(lista, i, n):
if
i == n:
return
1
else
:
return
lista[i]*multi_aux(lista[1:], i+1, n)
Índices
>>>multi( [1,4,6,2] )
multi_aux( [1,4,6,2], 0, 4 )
1*multi_aux( [4,6,2], 1, 4 )
1*4*multi_aux( [6,2], 2, 4 )
1*4*6*multi_aux( [2], 3, 4 )
1*4*6*2*multi_aux( [], 4, 4 )
48
límite
índice
Concatenación De Secuencias
S1+S2 retorna una secuencia formada por S1, seguida de S2. Deben ser del mismo tipo.
Ej:
>>>[1,2,3]+[4,5,6]
[1,2,3,4,5,6]
>>>[1,2]+(3,4)
Error por ser secuencias de diferentes tipos.

>>>[1,2,3]+[]
[1,2,3]
>>>[]+[1,2,3]
[1,2,3]

Código De Ejemplo
Hacer una función que reciba una lista y obtenga una lista de los números pares.
>>>pares( [1,4,8,9,11,16] )
[4,8,16]
E: lista
S:

lista con pares
R: lista no nula

def
pares
(lista):
if

isinstance
(lista,
list
) and lista != []:
return
pares_aux(lista)
else
:
return
'Error'

def

multi_aux
(lista):
if
lista == []:
return
[]
elif
lista[0] % 2 == 0:
return
[ lista[0] ] + pares_aux( lista[1:] )
else
:
return
pares_aux(

lista[1:] )
Slicing
Índices
Tarea
Algoritmo que encuentre el mayor elemento de una lista no nula.
>>>mayor([1,8,2,3,6])
def

mayor_aux
(lista):
if
lista[1:]

== []:
return
lista[0]
else
:
return
compara(lista[0], mayor_aux(lista[1:]))

def

compara
(x,y):
if
x>y:
return
x
else
:
return
y
E: lista
S: elemento mayor
R: lista no nula

def
mayor
(lista):
if
lista!=[]:
return
mayor_aux(lista)
else
:
return

'Error'
Corrida Manual
>>>mayor([1,8,2,3])
mayor_aux([1,8,2,3])
compara(1, mayor_aux([8,2,3]))
compara(1,compara(8, mayor_aux([2,3])))
compara(1,compara(8, compara(2, mayor_aux([3]))))
compara(1,compara(8,compara(2, 3)))
compara(1,compara(8,3))
compara(1,8)
8
Pila de comparaciones
Ejemplo en pila
Algoritmo que encuentre el mayor elemento de una lista no nula.
>>>mayor([1,8,2,3,6])
def

mayor_aux
(lista, mayor):
if
lista[1:] == []:
return
may
elif
lista[0] > may:
return
mayor_aux(lista[1:], lista[0])
else
:
return
mayor_aux(lista[1:], may)
E: lista
S: elemento mayor
R: lista no nula

def

mayor
(lista):
if
lista!=[]:
return
mayor_aux(lista[1:], lista[0])
else
:
return

'Error'
Corrida Manual
>>>mayor([1,8,2,3])
mayor_aux([8,2,3], 1)
mayor_aux([2,3],8)
mayor_aux([3], 8)
mayor_aux([], 8)
8
Ejemplo en cola
Menos memoria utilizada porque no se almacena en pila
Sumar dígitos de un número entero.
Pila

def

suma_dig
(num):
if

isinstance
(num,
int
):
return
suma_dig_aux(num)
else
:
return

'Error'

def

suma_dig_aux
(num):
if
num==0:
return
0
else
:
return
num%10 + suma_dig_aux(num//10)
Ejemplo
Cola

def

suma_dig
(num):
if

isinstance
(num,
int
):
return
suma_dig_aux(num, 0)
else
:
return

'Error'

def

suma_dig_aux
(num, resultado):
if
num==0:
return
resultado
else
:
return
(num // 10, resultado + num % 10)
Valor retorno
Operación
Operación
Valor inicio
Promedio sin el mayor ni el menor.
Pila

def

calificacion
(lista):
if

len
(lista) == 10:
suma = sume(lista)
menor = menor(lista)
mayor = mayor(lista)
return
(suma-mayor-menor)/8
else
:
return

'Error'
Ejemplo
Cola

def

calificacion
(lista):
if

len
(lista) == 10:
return
calif_aux(lista, lista[0], lista[0], 0)
else
:
return

'Error'

def

calif_aux
(lista, mayor, menor, suma):
if
lista == []:
return
(suma-mayor-menor)/8
elif
lista[0] > mayor:
return
calif_aux(lista[1:], lista[0], menor, suma+lista[0])
elif
lista[0] < menor:
return
calif_aux(lista[1:], mayor, lista[0], suma+lista[0])
else
:
return
calif_aux(lista[1:], mayor, menor, suma+lista[0])
Alternativa a la recurisividad de pila
En términos generales es más eficiente

Reglas
Normalmente se agregan más argumentos a la función auxiliar, esto en un esquema de función principal y auxiliar.

Estos argumentos que se agregan, normalmente contienen los resultados que se van a retornar.

Al encontrarse el caso base, se retornan el o los argumentos que contienen los resultados.

Al hacer la llamada recursiva, esta no se debe operar con nada, lo cual evita que se forme una pila.
Multiplicar los números de una lista


Slicing

#E: Lista
#S: Multiplicación Números
#R: N/A
def

multi
(lista):
return
multi_aux(lista,1)

def

multi_aux
(lista, resultado):
if
lista == []:
return
resultado
else
:
return
multi_aux(lista[1:], resultado*lista[0])
Ejemplo
Índices

def

multi
(lista):
return
multi_aux(lista, 0,
len
(lista), 1)

def

multi_aux
(lista, i, n, resultado):
if
i == n:
return
resultado
else
:
return
multi_aux(lista, i+1, n, resultado*lista[i])
Argumento agregado
para el resultado
Retorno del
resultado
Modificación
resultado
Índice inicial
Largo lista
Condición de parada cuando el índice iguala el largo de la lista
El uso de índices es más eficiente
Ejercicios
Dividir lista en dos listas de pares e impares
E: lista
S: lista con pares y lista con impares
R: lista no nula
def
par_impar
(lista):
if
lista==[]:
return
"Error"
else
:
return
par_impar_aux(lista, par, impar,
len
(lista), 0)
def

par_impar_aux
(lista, par, impar, largo, i):
if
i == a:
return
(par, impar)
elif
lista[i]%2==0:
return
par_impar_aux(lista, par+[lista[i]], impar, a, i+1)
else
:
return
par_impar_aux(lista, par, impar+[lista[i]], a, i+1)
Haga una función que reciba un número entero y que retorne un número formado con los dígitos impares del número de entrada y otro número formado con los dígitos pares.
>>>par_impar(678892)
(6882, 79)

Una función que reciba una lista con salarios de un grupo de personas y de ahí obtenga el salario más alto, el más bajo y el que más se repite.
>>>salarios([400.000, 250.000, 115.000, 700.000, 400.000])
(115.000, 700.000, 400.000)
Ejercicios
Cálculos Por Aproximación
Parte del análisis numérico
Consiste en hacer cálculos sucesivos hasta obtener un resultado "aceptable"

Ejemplo
Sumatoria de Leibniz. Converge hasta pi/8

1/1*3+1/5*7+1/9*11+...congruente pi/8 -> Función que aproxime pi
8*(1/1*3+1/5*7+1/9*11+...)congruente pi
#E: n (cantidad de términos)
#S: Aproximación de pi
#R: n>=1

def

leibniz
(n):
if
n>= 1:
return
leibniz_aux(n, 1, 0) * 8
else
:
return
"Error"
def

leibniz_aux
(n, i, resultado):
if
n == 0:
return
resultado
else
:
return
leibniz_aux(n-1, i+4, resultado+(1/ (i * i+2) ))
Índice aumenta en 4
Concepto de error
El error numérico es una medida de ajuste del cálculo de una magnitud con respecto al valor real o teórico de dicha magnitud.
Sirve para estimar el grado de precisión de una solución obtenida.
Si se conoce la respuesta real a un problema, la fórmula: |respuesta - aproximación| <= error, significaría que el resultado es aceptable.
Ejemplo
pi = 3.141592654, error = 0.001
n = 100, aproximación = 3.1426
|pi - 3.1426| <= error
0.0011 -> aceptable
A mayor cantidad de ceros, mayor la precisión de respuesta. En este caso hay al menos dos dígitos exactos con respecto al real.
#Leibniz con el concepto de error
#E: error
#S: aproximación de pi
#R: N/A

import
math
def

leibniz
(error):
return
leibniz_aux(error, 1, 0)*8
def

leibniz_aux
(error, i, resultado):
if

abs
(math.pi - resultado*8) <= error:
return
resultado
else
:
return
leibniz_aux(error, i, resultado + 1/(i*i_2))
>>>leibniz(0.0001)
Al menos 3 dígitos de precisión
Ejemplo
Cálculo de raíz cuadrada
1: Método de bisección. Consiste en ir partiendo en 2 el área de solución.
La fórmula es:
(Li+Ls)/2, donde
Li es límite inferor. Inicia en 0.
Ls es límite superior e inicia en y.
Calcular raíz de y.
CT: |y-aprox²|<= error 1^1/2 = 1.4142135623
#E: y, error
#S: aproximación de raíz de y
#R: y>0

def

biseccion
(error):
if
y>0:
return
biseccion_aux(y, error, 0, y, y/2)
else
:
return
"Error"
def

biseccion_aux
(y, error, li, ls, aprox):
if

abs
(y-aprox**2) <= error:
return
aprox
elif
aprox**2 > y:
return
biseccion_aux(y, error, li, aprox, (li+ls)/2)
else
:
return
biseccion_aux(y, error, aprox, ls, (li+ls)/2)
Li
Ls
0
1
2
1.5
Ls
Li
#E: y, error
#S: aproximación de raíz de y
#R: y>0

def

newton
(y, error):
if
y>0:
return
newton_aux(y, error, 1)
else
:
return

"Error"
def

newton_aux
(y, error,aprox):
if

abs
(y-aprox**2) <= error:
return
aprox
else
:
return
newton_aux(y, error, 0.5*(aprox+(y/aprox)))
Comparación
Método
Precisión
Llamadas
8
12
16
8
12
16
6
5
4
56
42
29
Bisección
Newton
def

suma_dig
(num):
if

isinstance
(num,

int
):
return
suma_dig_aux(
abs
(num))
else
:
return

'Error'

def

suma_dig_aux
(num):
if
num == 0:
return
0
else
:
return
num%10 + suma_dig_aux(num//10)
Full transcript