"- Escriba una rutina en python que reciba como entrada un número entero, $n$, e imprima los\n",
"números en la $n$-ésima fila del triángulo de Pascal. El programa debe verificar si el número\n",
"$n$ es entero, o arrojar un mensaje informando que ha habido un error del usuario en caso\n",
"contrario.\n",
"- Modifique la rutina anterior para que reciba un número variable de argumentos: $n_1$, $n_2$, $n_3$,...\n",
"y retorne una lista cuyo primer elemento es una lista conteniendo los números en la fila $n_1$\n",
"del triángulo de Pascal, el segundo elemento una lista con los números en la fila $n_2$, y así\n",
"sucesivamente.\n",
"\n",
"**Solución:** Hola, mi nombre es Sebastian Ordoñez (ordonezs). Para solucionar este ejercicio decidí hacer uso de la expresión conocida en términos de combinatorias para los elementos de la $n$-ésima fila. ASí pues, implemente una pequeña función auxiliar para calcular la combinatoria entre dos números y luego la usé para los propósitos específicos del triángulo."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Primera parte\n",
"\n",
"Primero se importa la libreria `math`, de la cual será útil especialmente la función que calcula el factorial de un entero positivo dado. "
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import math"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ahora, con el fin de usar la expresión matemática conocida para los elementos del triángulo de Pascal, se implementa una función auxiliar que permite calcular la combinatoria entre dos enteros positivos, $n$ y $k$, tal que $0\\leq k\\leq n$ y su expresión está dada por $nCk = \\frac{n!}{k!(n-k)!}$."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"def combinatory(n:int, k:int)->int:\n",
" \"\"\"\n",
" Esta fucnión calcula la combinatoria entre dos enteros dados.\n",
" \n",
" Input\n",
" ------\n",
" n (int): entero positivo mayor que k.\n",
" k (int): entero positivo menor que n.\n",
" \n",
" Output\n",
" ------\n",
" comb (int): entero resultante de hacer la combinación entre n y k.\n",
" \"\"\"\n",
" if k>n or n<0 or k<0: # Condición matemática para que la operación factorial esté bien definida.\n",
" \n",
" return \"Recuerde que el segundo argumento ha de ser mayor que el primero y ambos positivos.\"\n",
" \n",
" else:\n",
" f = math.factorial\n",
" comb = int(f(n)/(f(k)*f(n-k))) # Definición de combinatoria\n",
"\n",
" return comb "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Con el fin de completar lo requerido por el ejercicio se implementa la función principal `pascalTriangle`, la cual hace uso del hecho que la entrada de la $n$-ésima fila del triángulo en la posición $k$-ésima, está dada por $nCk$. Para más detalles consulte [aquí](https://en.wikipedia.org/wiki/Pascal%27s_triangle#Formula)."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"def pascalTriangle(n:int)->list:\n",
" \"\"\"\n",
" Esta función recibe un número natural n y retorna los elementos de la n-ésima fila del triángulo de Pascal.\n",
" La notación es tal que las primeras posiciones comienzan en cero.\n",
" \n",
" Input\n",
" ------\n",
" n (int): número que se espera que sea entero.\n",
" \n",
" Output\n",
" ------\n",
" triangleRow (list): lista de números que corresponden a la n-ésima fila del triángulo de Pascal.\n",
" \"\"\"\n",
" if type(n)!= int or n<0:\n",
" return \"The number you gave is either non integer or is less than zero.\"\n",
" else: \n",
" triangleRow = []\n",
" for k in range(n+1):\n",
" triangleRow.append(combinatory(n,k))\n",
" return triangleRow"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ahora podemos probar la función principal para los casos triviales y algunos más complicados."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1]\n",
"[1, 1]\n",
"[1, 2, 1]\n",
"[1, 3, 3, 1]\n",
"[1, 4, 6, 4, 1]\n",
"[1, 5, 10, 10, 5, 1]\n",
"[1, 6, 15, 20, 15, 6, 1]\n"
]
}
],
"source": [
"print(pascalTriangle(0))\n",
"print(pascalTriangle(1))\n",
"print(pascalTriangle(2))\n",
"print(pascalTriangle(3))\n",
"print(pascalTriangle(4))\n",
"print(pascalTriangle(5))\n",
"print(pascalTriangle(6))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Segunda parte\n",
"\n",
"Continuando con la segunda parte del ejercicio, se procede a extender la función `pascalTriangle` a múltiples argumentos."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"def pascalTriangleExtended(*args)->list:\n",
" \"\"\"\n",
" Esta función recibe un número no definido de argumentos que se espera que correspondan a números naturales.\n",
" \n",
" Input\n",
" ------\n",
" *args: lista de argumentos con longitud no definida los cuales se espera que correspondan a números naturales.\n",
" \n",
" Output\n",
" ------\n",
" allRows (list): lista que contiene listas, las cuales corresponden a las filas del triángulo de Pascal asociadas\n",
" a los argumentos dados n1, n2, n3, etc.\n",
" \"\"\"\n",
" allRows = []\n",
" for jj in args:\n",
" if type(jj)!=int or jj<0:\n",
" return \"At least one of the numbers you gave is either non integer or is less than zero.\"\n",
" break\n",
" else:\n",
" triangleRow = []\n",
" for k in range(jj+1):\n",
" triangleRow.append(combinatory(jj,k))\n",
" allRows.append(triangleRow)\n",
" \n",
" return allRows"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Podemos ahora comprobar la utilidad de esta nueva función `pascalTriangleExtended` usando como ejemplo algo que se hizo arriba en la primera parte en varias líneas."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[[1],\n",
" [1, 1],\n",
" [1, 2, 1],\n",
" [1, 3, 3, 1],\n",
" [1, 4, 6, 4, 1],\n",
" [1, 5, 10, 10, 5, 1],\n",
" [1, 6, 15, 20, 15, 6, 1]]"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pascalTriangleExtended(0,1,2,3,4,5,6)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
%% Cell type:markdown id: tags:
# Ejercicio No. 2 - Triángulo de Pascal
**Enunciado:**
- 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.
- Modifique la rutina anterior para que reciba un número variable de argumentos: $n_1$, $n_2$, $n_3$,...
y retorne una lista cuyo primer elemento es una lista conteniendo los números en la fila $n_1$
del triángulo de Pascal, el segundo elemento una lista con los números en la fila $n_2$, y así
sucesivamente.
**Solución:** Hola, mi nombre es Sebastian Ordoñez (ordonezs). Para solucionar este ejercicio decidí hacer uso de la expresión conocida en términos de combinatorias para los elementos de la $n$-ésima fila. ASí pues, implemente una pequeña función auxiliar para calcular la combinatoria entre dos números y luego la usé para los propósitos específicos del triángulo.
%% Cell type:markdown id: tags:
## Primera parte
Primero se importa la libreria `math`, de la cual será útil especialmente la función que calcula el factorial de un entero positivo dado.
%% Cell type:code id: tags:
``` python
importmath
```
%% Cell type:markdown id: tags:
Ahora, con el fin de usar la expresión matemática conocida para los elementos del triángulo de Pascal, se implementa una función auxiliar que permite calcular la combinatoria entre dos enteros positivos, $n$ y $k$, tal que $0\leq k\leq n$ y su expresión está dada por $nCk = \frac{n!}{k!(n-k)!}$.
%% Cell type:code id: tags:
``` python
defcombinatory(n:int,k:int)->int:
"""
Esta fucnión calcula la combinatoria entre dos enteros dados.
Input
------
n (int): entero positivo mayor que k.
k (int): entero positivo menor que n.
Output
------
comb (int): entero resultante de hacer la combinación entre n y k.
"""
ifk>norn<0ork<0:# Condición matemática para que la operación factorial esté bien definida.
return"Recuerde que el segundo argumento ha de ser mayor que el primero y ambos positivos."
else:
f=math.factorial
comb=int(f(n)/(f(k)*f(n-k)))# Definición de combinatoria
returncomb
```
%% Cell type:markdown id: tags:
Con el fin de completar lo requerido por el ejercicio se implementa la función principal `pascalTriangle`, la cual hace uso del hecho que la entrada de la $n$-ésima fila del triángulo en la posición $k$-ésima, está dada por $nCk$. Para más detalles consulte [aquí](https://en.wikipedia.org/wiki/Pascal%27s_triangle#Formula).
%% Cell type:code id: tags:
``` python
defpascalTriangle(n:int)->list:
"""
Esta función recibe un número natural n y retorna los elementos de la n-ésima fila del triángulo de Pascal.
La notación es tal que las primeras posiciones comienzan en cero.
Input
------
n (int): número que se espera que sea entero.
Output
------
triangleRow (list): lista de números que corresponden a la n-ésima fila del triángulo de Pascal.
"""
iftype(n)!=intorn<0:
return"The number you gave is either non integer or is less than zero."
else:
triangleRow=[]
forkinrange(n+1):
triangleRow.append(combinatory(n,k))
returntriangleRow
```
%% Cell type:markdown id: tags:
Ahora podemos probar la función principal para los casos triviales y algunos más complicados.
%% Cell type:code id: tags:
``` python
print(pascalTriangle(0))
print(pascalTriangle(1))
print(pascalTriangle(2))
print(pascalTriangle(3))
print(pascalTriangle(4))
print(pascalTriangle(5))
print(pascalTriangle(6))
```
%% Output
[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]
%% Cell type:markdown id: tags:
## Segunda parte
Continuando con la segunda parte del ejercicio, se procede a extender la función `pascalTriangle` a múltiples argumentos.
%% Cell type:code id: tags:
``` python
defpascalTriangleExtended(*args)->list:
"""
Esta función recibe un número no definido de argumentos que se espera que correspondan a números naturales.
Input
------
*args: lista de argumentos con longitud no definida los cuales se espera que correspondan a números naturales.
Output
------
allRows (list): lista que contiene listas, las cuales corresponden a las filas del triángulo de Pascal asociadas
a los argumentos dados n1, n2, n3, etc.
"""
allRows=[]
forjjinargs:
iftype(jj)!=intorjj<0:
return"At least one of the numbers you gave is either non integer or is less than zero."
break
else:
triangleRow=[]
forkinrange(jj+1):
triangleRow.append(combinatory(jj,k))
allRows.append(triangleRow)
returnallRows
```
%% Cell type:markdown id: tags:
Podemos ahora comprobar la utilidad de esta nueva función `pascalTriangleExtended` usando como ejemplo algo que se hizo arriba en la primera parte en varias líneas.
