"En la primera celda tomamos una lista de entrada del usuario. En la segunda usamos la función `.split` para crear una lista con cada palabra, la ordenamos con `sorted`, y finalmente la juntamos de nuevo con `.join` (siempre tenemos en cuenta que el separador es -)."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Palabras de entrada (separadas por guiones): último-intento-ya-después-de-haber-renombrado-la-variable\n"
]
}
],
"source": [
"inStr = str(input(r\"Palabras de entrada (separadas por guiones): \"))"
"Para la primera parte importamos la función `factorial` y definimos una función que retorna el coeficiente binomial $n\\choose k$."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"from math import factorial"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"binomCoef = lambda n, k: factorial(n)/(factorial(k)*factorial(n-k))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"El usuario inserta $n$ deseado: si el valor de la entrada es igual sin importar si se transforma a un float o a un int, entonces podemos concluir que $n \\in \\mathbb{Z}$."
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"¿Número de la fila?8\n"
]
}
],
"source": [
"N = float(input(r\"¿Número de la fila?\"))\n",
"if N != int(N):\n",
" print(\"Error: n no es entero\")\n",
"N = int(N)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finamente, poblamos la lista `nRow` con los coeficientes de la fila correspondiente en el triángulo de Pascal e imprimimos."
"Para la segunda parte reusamos una línea del primer punto, e insertamos los números de las filas separados por puntos; esto ayuda a que no se puedan insertar números no enteros. Luego convertimos cada elemento en un int."
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Inserte los números de las filas separados por puntos: 0.1.2.3.4.5\n"
]
}
],
"source": [
"manyN = input(\"Inserte los números de las filas separados por puntos: \")\n",
"manyN = [int(n) for n in manyN.split(\".\")]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Reusamos el código de la parte anterior, salvo que esta vez está dentro de otro loop que itera sobre cada fila $n_i$. Las filas que se obtienen se adicionan a una lista `rows`."
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [],
"source": [
"rows = []\n",
"for N in manyN:\n",
" nRow=[]\n",
" for k in range(N+1):\n",
" nRow.append(binomCoef(N, k))\n",
" rows.append(nRow)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finalmente imprimimos cada fila en orden de entrada. En este caso se muestran las filas de la 0 a la 5"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1.0]\n",
"[1.0, 1.0]\n",
"[1.0, 2.0, 1.0]\n",
"[1.0, 3.0, 3.0, 1.0]\n",
"[1.0, 4.0, 6.0, 4.0, 1.0]\n",
"[1.0, 5.0, 10.0, 10.0, 5.0, 1.0]\n"
]
}
],
"source": [
"for i in range(len(manyN)):\n",
" print(rows[i])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Ejercicio 3\n",
"Con la función `newEntry` se puede poblar el diccionario.\n",
"Definimos las tres funciones que se piden. Todas usan el mismo principio de iterar sobre las llaves de `compas`, e inspeccionar los contenidos de cada una. En la función que retorna las instituciones usamos un set para evitar entradas duplicadas."
]
},
{
"cell_type": "code",
"execution_count": 113,
"metadata": {},
"outputs": [],
"source": [
"def sortPais(d, pais):\n",
" names = []\n",
" for matter in d:\n",
" if d[matter][\"país\"] == pais: \n",
" names.append(matter)\n",
" ## En caso de necesitar tabular de otra manera se deja así.\n",
" ## De lo contrario se puede hacer un solo loop.\n",
En la primera celda tomamos una lista de entrada del usuario. En la segunda usamos la función `.split` para crear una lista con cada palabra, la ordenamos con `sorted`, y finalmente la juntamos de nuevo con `.join` (siempre tenemos en cuenta que el separador es -).
%% Cell type:code id: tags:
``` python
inStr=str(input(r"Palabras de entrada (separadas por guiones): "))
```
%% Output
Palabras de entrada (separadas por guiones): último-intento-ya-después-de-haber-renombrado-la-variable
El usuario inserta $n$ deseado: si el valor de la entrada es igual sin importar si se transforma a un float o a un int, entonces podemos concluir que $n \in \mathbb{Z}$.
%% Cell type:code id: tags:
``` python
N=float(input(r"¿Número de la fila?"))
ifN!=int(N):
print("Error: n no es entero")
N=int(N)
```
%% Output
¿Número de la fila?8
%% Cell type:markdown id: tags:
Finamente, poblamos la lista `nRow` con los coeficientes de la fila correspondiente en el triángulo de Pascal e imprimimos.
Para la segunda parte reusamos una línea del primer punto, e insertamos los números de las filas separados por puntos; esto ayuda a que no se puedan insertar números no enteros. Luego convertimos cada elemento en un int.
%% Cell type:code id: tags:
``` python
manyN=input("Inserte los números de las filas separados por puntos: ")
manyN=[int(n)forninmanyN.split(".")]
```
%% Output
Inserte los números de las filas separados por puntos: 0.1.2.3.4.5
%% Cell type:markdown id: tags:
Reusamos el código de la parte anterior, salvo que esta vez está dentro de otro loop que itera sobre cada fila $n_i$. Las filas que se obtienen se adicionan a una lista `rows`.
%% Cell type:code id: tags:
``` python
rows=[]
forNinmanyN:
nRow=[]
forkinrange(N+1):
nRow.append(binomCoef(N,k))
rows.append(nRow)
```
%% Cell type:markdown id: tags:
Finalmente imprimimos cada fila en orden de entrada. En este caso se muestran las filas de la 0 a la 5
%% Cell type:code id: tags:
``` python
foriinrange(len(manyN)):
print(rows[i])
```
%% Output
[1.0]
[1.0, 1.0]
[1.0, 2.0, 1.0]
[1.0, 3.0, 3.0, 1.0]
[1.0, 4.0, 6.0, 4.0, 1.0]
[1.0, 5.0, 10.0, 10.0, 5.0, 1.0]
%% Cell type:markdown id: tags:
# Ejercicio 3
Con la función `newEntry` se puede poblar el diccionario.
Definimos las tres funciones que se piden. Todas usan el mismo principio de iterar sobre las llaves de `compas`, e inspeccionar los contenidos de cada una. En la función que retorna las instituciones usamos un set para evitar entradas duplicadas.
%% Cell type:code id: tags:
``` python
defsortPais(d,pais):
names=[]
formatterind:
ifd[matter]["país"]==pais:
names.append(matter)
## En caso de necesitar tabular de otra manera se deja así.
