Skip to content
Snippets Groups Projects
Commit a25d5e78 authored by David Ramos Salamanca's avatar David Ramos Salamanca
Browse files

Add second part of problem

parent 3788df3a
No related branches found
No related tags found
No related merge requests found
......@@ -14280,9 +14280,8 @@ a.anchor-link {
</div>
<div class="jp-Cell-inputWrapper"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<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>
$$ {n\choose k} = \frac{n!}{k!(n-k)!} .$$
</div>
</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell jp-mod-noOutputs ">
<div class="jp-Cell-inputWrapper">
......@@ -14641,6 +14640,124 @@ $$ {n\choose k} = \frac{n!}{k!(n-k)!} .$$</p>
 
</div>
 
</div>
<div class="jp-Cell-inputWrapper"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<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>
</div>
</div>
<div class="jp-Cell-inputWrapper"><div class="jp-InputPrompt jp-InputArea-prompt">
</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
<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>
</div>
</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell jp-mod-noOutputs ">
<div class="jp-Cell-inputWrapper">
<div class="jp-InputArea jp-Cell-inputArea">
<div class="jp-InputPrompt jp-InputArea-prompt">In&nbsp;[12]:</div>
<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
<div class="CodeMirror cm-s-jupyter">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">multipascal</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">):</span>
<span class="n">nmax</span> <span class="o">=</span> <span class="nb">max</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">)</span>
<span class="n">rows</span> <span class="o">=</span> <span class="p">[]</span>
<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">&#39;Error: uno o más de los números ingresados no es entero&#39;</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">rows</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="k">return</span> <span class="n">rows</span>
<span class="k">else</span><span class="p">:</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 &quot;columnas&quot;</span>
<span class="k">if</span> <span class="n">k</span> <span class="o">==</span> <span class="mi">0</span> <span class="ow">or</span> <span class="n">k</span> <span class="o">==</span> <span class="n">i</span><span class="p">:</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="k">else</span><span class="p">:</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>
<span class="n">rows</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">row</span><span class="p">)</span> <span class="c1"># guardo la fila actual</span>
<span class="n">row</span> <span class="o">=</span> <span class="p">[]</span> <span class="c1"># vacío la fila para volverla a llenar</span>
<span class="k">return</span> <span class="n">rows</span>
</pre></div>
</div>
</div>
</div>
</div>
</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell ">
<div class="jp-Cell-inputWrapper">
<div class="jp-InputArea jp-Cell-inputArea">
<div class="jp-InputPrompt jp-InputArea-prompt">In&nbsp;[13]:</div>
<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
<div class="CodeMirror cm-s-jupyter">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">multipascal</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span>
</pre></div>
</div>
</div>
</div>
</div>
<div class="jp-Cell-outputWrapper">
<div class="jp-OutputArea jp-Cell-outputArea">
<div class="jp-OutputArea-child">
<div class="jp-OutputPrompt jp-OutputArea-prompt">Out[13]:</div>
<div class="jp-RenderedText jp-OutputArea-output jp-OutputArea-executeResult" data-mime-type="text/plain">
<pre>[[1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]</pre>
</div>
</div>
</div>
</div>
</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell ">
<div class="jp-Cell-inputWrapper">
<div class="jp-InputArea jp-Cell-inputArea">
<div class="jp-InputPrompt jp-InputArea-prompt">In&nbsp;[14]:</div>
<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
<div class="CodeMirror cm-s-jupyter">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">multipascal</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mf">4.1</span><span class="p">)</span>
</pre></div>
</div>
</div>
</div>
</div>
<div class="jp-Cell-outputWrapper">
<div class="jp-OutputArea jp-Cell-outputArea">
<div class="jp-OutputArea-child">
<div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
<div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain">
<pre>Error: uno o más de los números ingresados no es entero
</pre>
</div>
</div>
</div>
</div>
</div>
</body>
 
......
%% 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
import numpy as np
```
%% Cell type:code id: tags:
``` python
def pascal1(n):
if int(n)==n: # reviso que el número sea entero
row = ''
for i in range(n+1): # calculo cada uno de los coeficientes binomiales y lo almaceno en fila
row += str(int(np.math.factorial(n)/(np.math.factorial(i)*np.math.factorial(n-i)))) + '\t'
print(row)
else:
print('Error: el número ingresado no es entero')
```
%% Cell type:code id: tags:
``` python
pascal1(0)
```
%% Output
1
%% Cell type:code id: tags:
``` python
pascal1(4)
```
%% Output
1 4 6 4 1
%% Cell type:code id: tags:
``` python
pascal1(3.3)
```
%% Output
Error: el número ingresado no es entero
%% Cell type:markdown id: tags:
## Solución 2 (cody)
%% Cell type:markdown id: tags:
La otra opción es construir el triángulo de pascal hasta la *n-ésima* fila e imprimirla.
%% Cell type:code id: tags:
``` python
def pascal2(n):
if int(n) != n:
print('Error: el número ingresado no es entero')
elif n == 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
for i in range(1,n+1): # iterando sobre el número de filas
for k in range(i+1): # segunda iteración (shame on me) para moverse en "columnas"
if k == 0 or k == 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' for number in frow])) # 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
def multipascal(*args):
nmax = max(*args)
rows = []
if not all(int(n) == n for n in args): # 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')
elif nmax == 0: # sabemos que la primera fila es un 1
rows.append([int(1)])
return rows
else:
prow = (int(1)) # guardando la primera fila, se usan tuplas para que sea inmutable
row =[] # lista donde se crearán las filas
for i in range(1,nmax+1): # iterando sobre el número de filas
for k in range(i+1): # segunda iteración (shame on me) para moverse en "columnas"
if k == 0 or k == 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
rows.append(row) # guardo la fila actual
row = [] # vacío la fila para volverla a llenar
return rows
```
%% Cell type:code id: tags:
``` python
multipascal(1,2,3,4)
```
%% Output
[[1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]
%% Cell type:code id: tags:
``` python
multipascal(1,2,3,4.1)
```
%% Output
Error: uno o más de los números ingresados no es entero
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment