<p>Los números en la <em>n-ésima</em> (empezando en cero) fila del triángulo de Pascal corresponden a los coeficientes binomiales ${n\choose 0},\,{n\choose 1},\,...,\,{n\choose n}$ donde
$$ {n\choose k} = \frac{n!}{k!(n-k)!} .$$</p>
<p>Los números en la <em>n-ésima</em> (empezando en cero) fila del triángulo de Pascal corresponden a los coeficientes binomiales ${n\choose 0},\,{n\choose 1},\,...,\,{n\choose n}$ donde</p>
<p>Modifique la rutina anterior para que reciba un número variable de argumentos: <em>n1</em>, <em>n2</em>, <em>n3</em>,...y retorne una lista cuyo primer elemento es una lista conteniendo los números en la fila <em>n1</em> del triángulo de Pascal, el segundo elemento una lista con los números en la fila <em>n2</em>, y así sucesivamente.</p>
<p>Para este caso la estrategia será buscar el número más alto de los brindados por el usuario y la estructura de la rutina es la misma, la única diferencia es que se guardan algunas de las filas intermedias.</p>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">all</span><span class="p">(</span><span class="nb">int</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="o">==</span> <span class="n">n</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="n">args</span><span class="p">):</span> <span class="c1"># usando all() para verificar que todos los números sean enteros</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">'Error: uno o más de los números ingresados no es entero'</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">nmax</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span> <span class="c1"># sabemos que la primera fila es un 1</span>
<span class="n">prow</span> <span class="o">=</span> <span class="p">(</span><span class="nb">int</span><span class="p">(</span><span class="mi">1</span><span class="p">))</span> <span class="c1"># guardando la primera fila, se usan tuplas para que sea inmutable</span>
<span class="n">row</span> <span class="o">=</span><span class="p">[]</span> <span class="c1"># lista donde se crearán las filas</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="n">nmax</span><span class="o">+</span><span class="mi">1</span><span class="p">):</span> <span class="c1"># iterando sobre el número de filas</span>
<span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">):</span> <span class="c1"># segunda iteración (shame on me) para moverse en "columnas"</span>
<span class="n">row</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="nb">int</span><span class="p">(</span><span class="mi">1</span><span class="p">))</span> <span class="c1"># el primer y el último número es 1</span>
<span class="n">row</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">prow</span><span class="p">[</span><span class="n">k</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">+</span><span class="n">prow</span><span class="p">[</span><span class="n">k</span><span class="p">])</span> <span class="c1"># elementos interiores como suma de elementos de la fila anterior</span>
<span class="n">prow</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">(</span><span class="n">row</span><span class="p">)</span> <span class="c1"># re asigno la fila anterior (como una tupla) para la nueva iteración</span>
"Los números en la *n-ésima* (empezando en cero) fila del triángulo de Pascal corresponden a los coeficientes binomiales ${n\\choose 0},\\,{n\\choose 1},\\,...,\\,{n\\choose n}$ donde\n",
"\n",
"$$ {n\\choose k} = \\frac{n!}{k!(n-k)!} .$$"
]
},
...
...
@@ -236,6 +237,86 @@
"source": [
"pascal2(3.1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Para este caso la estrategia será buscar el número más alto de los brindados por el usuario y la estructura de la rutina es la misma, la única diferencia es que se guardan algunas de las filas intermedias."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"def multipascal(*args):\n",
" nmax = max(*args)\n",
" rows = []\n",
" if not all(int(n) == n for n in args): # usando all() para verificar que todos los números sean enteros\n",
" print('Error: uno o más de los números ingresados no es entero')\n",
" elif nmax == 0: # sabemos que la primera fila es un 1\n",
" rows.append([int(1)])\n",
" return rows\n",
" else:\n",
" prow = (int(1)) # guardando la primera fila, se usan tuplas para que sea inmutable\n",
" row =[] # lista donde se crearán las filas\n",
" for i in range(1,nmax+1): # iterando sobre el número de filas\n",
" for k in range(i+1): # segunda iteración (shame on me) para moverse en \"columnas\"\n",
" if k == 0 or k == i:\n",
" row.append(int(1)) # el primer y el último número es 1\n",
" else:\n",
" row.append(prow[k-1]+prow[k]) # elementos interiores como suma de elementos de la fila anterior\n",
" prow = tuple(row) # re asigno la fila anterior (como una tupla) para la nueva iteración\n",
" rows.append(row) # guardo la fila actual\n",
" row = [] # vacío la fila para volverla a llenar\n",
"Error: uno o más de los números ingresados no es entero\n"
]
}
],
"source": [
"multipascal(1,2,3,4.1)"
]
}
],
"metadata": {
...
...
%% Cell type:markdown id: tags:
# David Ramos - UIS
%% Cell type:markdown id: tags:
## Problema: Triángulo de Pascal
%% Cell type:markdown id: tags:
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.
%% Cell type:markdown id: tags:
## Solución 1 (mathy)
%% Cell type:markdown id: tags:
Los números en la *n-ésima* (empezando en cero) fila del triángulo de Pascal corresponden a los coeficientes binomiales ${n\choose 0},\,{n\choose 1},\,...,\,{n\choose n}$ donde
$$ {n\choose k} = \frac{n!}{k!(n-k)!} .$$
%% Cell type:code id: tags:
``` python
importnumpyasnp
```
%% Cell type:code id: tags:
``` python
defpascal1(n):
ifint(n)==n:# reviso que el número sea entero
row=''
foriinrange(n+1):# calculo cada uno de los coeficientes binomiales y lo almaceno en fila
La otra opción es construir el triángulo de pascal hasta la *n-ésima* fila e imprimirla.
%% Cell type:code id: tags:
``` python
defpascal2(n):
ifint(n)!=n:
print('Error: el número ingresado no es entero')
elifn==0:# sabemos que la primera fila es un 1
print('1')
else:
prow=(int(1))# guardando la primera fila, se usan tuplas para que sea inmutable
row=[]# lista donde se crearán las filas
foriinrange(1,n+1):# iterando sobre el número de filas
forkinrange(i+1):# segunda iteración (shame on me) para moverse en "columnas"
ifk==0ork==i:
row.append(int(1))# el primer y el último número es 1
else:
row.append(prow[k-1]+prow[k])# elementos interiores como suma de elementos de la fila anterior
prow=tuple(row)# re asigno la fila anterior (como una tupla) para la nueva iteración
frow=row# guardo la fila actual
row=[]# vacío la fila para volverla a llenar
print(''.join([str(number)+'\t'fornumberinfrow]))# imprimo los número separados por tab
```
%% Cell type:code id: tags:
``` python
pascal2(0)
```
%% Output
1
%% Cell type:code id: tags:
``` python
pascal2(1)
```
%% Output
1 1
%% Cell type:code id: tags:
``` python
pascal2(2)
```
%% Output
1 2 1
%% Cell type:code id: tags:
``` python
pascal2(3)
```
%% Output
1 3 3 1
%% Cell type:code id: tags:
``` python
pascal2(3.1)
```
%% Output
Error: el número ingresado no es entero
%% Cell type:markdown id: tags:
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.
%% Cell type:markdown id: tags:
Para este caso la estrategia será buscar el número más alto de los brindados por el usuario y la estructura de la rutina es la misma, la única diferencia es que se guardan algunas de las filas intermedias.
%% Cell type:code id: tags:
``` python
defmultipascal(*args):
nmax=max(*args)
rows=[]
ifnotall(int(n)==nforninargs):# usando all() para verificar que todos los números sean enteros
print('Error: uno o más de los números ingresados no es entero')
elifnmax==0:# sabemos que la primera fila es un 1
rows.append([int(1)])
returnrows
else:
prow=(int(1))# guardando la primera fila, se usan tuplas para que sea inmutable
row=[]# lista donde se crearán las filas
foriinrange(1,nmax+1):# iterando sobre el número de filas
forkinrange(i+1):# segunda iteración (shame on me) para moverse en "columnas"
ifk==0ork==i:
row.append(int(1))# el primer y el último número es 1
else:
row.append(prow[k-1]+prow[k])# elementos interiores como suma de elementos de la fila anterior
prow=tuple(row)# re asigno la fila anterior (como una tupla) para la nueva iteración
