Escriba una rutina en python que reciba como entrada un número entero, n, e imprima los números en la n-ésima fila del triángulo de Pascal. El programa debe verificar si el número n es entero, o arrojar un mensaje informando que ha habido un error del usuario en caso contrario.
La funcion corazon_pascal(n)
es una funcion que usa recursión para retornar la fila n
del triangulo de Pascal.
El "algoritmo" para llevar a cabo esta tarea se puede resumir en los siguientes pasos:
Se crea una lista vacia llamada lista
donde se guardarán los elementos del trianglo de Pascal.
En el caso donde el entero introducido n
es cero, se imprime un mensaje solicitando al ususario un numero entero diferente de cero.
En el caso donde el entero introdcido n
es uno, se concatena la lista vacialista
con la lista [1]
y este resultado se guarda en la variable lista
.
Cuando el entero introducido n
es mayor a uno, se "llama" a la funcion corazon_pascal(n)
cuando el argumento es n-1
, esto retorna la fila n-1
del triangulo de Pascal en una lista. Sumamos los elementos consecutivos de esta lista y añadimos cada una de estas sumas a una nueva lista; esta ultima la creamos usando list comprehension.
def corazon_pascal(n):
"""
Esta función recibe un argumento de tipo entero
Retorna una lista con los numeros tipo int de la fila n del triangulo de Pascal
"""
lista=[]
if n==0:
print("""
Estamos etiquetando las filas del triangulo de Pascal
desde el 1. La fila 1 es [1], la fila 2 es [1,1], etc
""")
elif n==1:
lista=lista+[1]
#elif n==2:
#lista=lista+[1,1]
else:
lista_antes=corazon_pascal(n-1)
# La condicion if i<len(lista_antes)-1 es para evitar evaluar indices mayores
# que la longitud de la lista lista_antes, ya que en lo que se apenda esta
# lista_antes[i+1].
lista=[1]+[lista_antes[i]+lista_antes[i+1] for i,_ in enumerate(lista_antes) if i<len(lista_antes)-1]+[1]
return lista
La función triangulo_pascal(n)
recibe una variable de tipo string y comprueba que sea de caracter numerico usando el metodo .isdecimal()
. Se escogio este metodo pues retorna True
cuando los caracteres de n
"representan" un numero entero; y retorna False
cuando los caracteres "representan" un numero decimal o un numero complejo.
Si la parte anterior de la funcion comprueba que n
"representa" un entero, este se convierte a una variable de tipo entero usando la funcion int
de Python. Se invoca la función corazon_pascal
y se devuelve el resultado de esta.
En caso contrario, se imprime en pantalla un mensaje que le indica al usuario que el numero que ingresó NO es de tipo entero.
La linea final:
return ""
se coloco para evitar que se imprima None
en pantalla cuando se llama a esta función.
def triangulo_pascal(n):
"""
Esta funcion recibe un string n
En caso de que la variable n NO sea un numero entero
imprime un mensaje en pantalla solicitando un entero
"""
es_entero=n.isdecimal()
if es_entero:
return corazon_pascal(int(n))
else:
return print("""El numero introducido NO es un numero entero,
por favor introduzca un numero ENTERO""")
return ""
numero_usuario=input("""
Introduzca un numero entero mayor que cero;
se retornará la fila n del triangulo de Pascal
""")
print("")
print(triangulo_pascal(numero_usuario))
3 [1, 2, 1]
Modifique la rutina anterior para que reciba un número variable de argumentos: n1, n2, n3,... y retorne una lista cuyo primer elemento es una lista conteniendo los números en la fila n1 del triángulo de Pascal, el segundo elemento una lista con los números en la fila n2, y así sucesivamente.
Para trabajar este problema, empezamos solicitando al usuario una secuencia de numeros separados por comas; para ello usamos la función input()
. Esta secuencia queda guardada en una variable de tipo string que llamamos varios_numeros
.
Usando el metodo varios_numeros.split(",")
, Python divide el contenido de la variable varios_numeros
donde encuentra una coma. Cada una de estas "palabras" las guarda en una lista. En nuestro caso llamamos a esta lista lista_de_numeros_string
.
Finalmente, se crea una lista llamada filas_del_tri_pascal
cuyos elementos serán las filas del triangulo de Pascal que el usuario solicitó. Para ello usamos list comprehension llamando a la función triangulo_pascal(n)
para cada elemento de la lista lista_de_numeros_string
.
Es importante mencionar que la función triangulo_pascal(n)
recibe como argumento una variable de tipo string.
Usando un ciclo for
imprimimos el contenido de la lista filas_del_tri_pascal
de manera comprensible.
varios_numeros=input("""
Introduzca una secuencia de numeros ENTEROS separados por comas,
e.g. n1,n2,n3
Se retornará una lista que contiene las filas n1,n2 y n3 del
triangulo de Pascal
""")
lista_de_numeros_string=varios_numeros.split(",")
filas_del_tri_pascal=[triangulo_pascal(h) for h in lista_de_numeros_string]
print("")
print("")
print("[")
for s in filas_del_tri_pascal:
print(s)
print("]")
2,4,6 [ [1, 1] [1, 3, 3, 1] [1, 5, 10, 10, 5, 1] ]
Quise ver como se comportan las filas del triangulo de Pascal si consideraramos cada una de sus filas como un numero.
Es decir, como se vería la grafica de una función $f(n)$ que cumple
$$ f(1)=1\\ f(2)=11\\ f(3)=121\\ f(4)=1331\\ f(5)=14641\\ f(6)=15101051\\ .\\ .\\ . $$# Prueba
import numpy as np
import matplotlib.pyplot as plt
def cachipai(l):
"""
Esta funcion recibe una lista con los numeros de una fila del triangulo de Pascal
Retorna el numero (tipo int) que se construiría si pegaramos todos los elementos de la lista.
Ejemplo: cachipai([1,2,1]) retorna 121.
cachipai([1,5,10,10,5,1]) retorna 15101051
"""
aux=""
for f in l:
aux=aux+str(f)
return int(aux)
prueba=cachipai([1,2,1])
print(prueba)
print(type(prueba))
121 <class 'int'>
x=range(1,10)
print(x)
prueba=[triangulo_pascal(str(i)) for i in x]
print(prueba)
y=[cachipai(j) for j in prueba]
print("")
print(y)
range(1, 10) [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1]] [1, 11, 121, 1331, 14641, 15101051, 1615201561, 172135352171, 18285670562881]
#plt.plot(x,y,"b-*")
#plt.show()
plt.loglog(x,y,"b-o")
plt.show()