"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": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Palabras de entrada (separadas por guiones): esta-es-una-serie-de-palabras-que-serviran-como-prueba-para-el-código\n"
]
}
],
"source": [
"inStr = str(input(r\"Palabras de entrada (separadas por guiones): \"))"
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): esta-es-una-serie-de-palabras-que-serviran-como-prueba-para-el-código
"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": 14,
"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. Usamos una comprensión de lista (en lugar de un for) para mayor eficiencia."
"Para la segunda parte reusamos una línea del **Ejercicio 1**, 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": 26,
"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 un loop que itera sobre cada fila $n_i$. Las filas que se obtienen se adicionan a una lista `rows`. Se podría usar una comprensión de lista dentro de la otra (**ver comentario**) pero usamos un for para mejor legibilidad."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"rows = []\n",
"for N in manyN:\n",
" nRow = [binomCoef(N, k) for k in range(N+1)]\n",
" rows.append(nRow)\n",
"\n",
"#También funcionaría\n",
"\n",
"#rows=[[binomCoef(N, k) for k in range(N+1)] for N in manyN]\n",
"\n",
"#pero es menos legible."
]
},
{
"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": 30,
"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": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"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:
##### Felipe Reyes Osorio (@reyesf)
# Ejercicio 2
## Parte 1
Para la primera parte importamos la función `factorial` y definimos una función que retorna el coeficiente binomial $n\choose k$.
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. Usamos una comprensión de lista (en lugar de un for) para mayor eficiencia.
Para la segunda parte reusamos una línea del **Ejercicio 1**, 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 un loop que itera sobre cada fila $n_i$. Las filas que se obtienen se adicionan a una lista `rows`. Se podría usar una comprensión de lista dentro de la otra (**ver comentario**) pero usamos un for para mejor legibilidad.
%% Cell type:code id: tags:
``` python
rows=[]
forNinmanyN:
nRow=[binomCoef(N,k)forkinrange(N+1)]
rows.append(nRow)
#También funcionaría
#rows=[[binomCoef(N, k) for k in range(N+1)] for N in manyN]
#pero es menos legible.
```
%% 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
"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 -)."
"\n",
]
},
{
"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",
"# Ejercicio 3\n",
"Con la función `newEntry` se puede poblar el diccionario.\n",
"Con la función `newEntry` se puede poblar el diccionario. No era parte del ejercicio pero me facilitó el proceso.\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."
"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. \n",
"\n",
"* La primera retorna una lista con los miembros del país seleccionado. Esta lista está lista para tabular.\n",
"* La segunda promedia las edades de todos en `compas`.\n",
"* La tercera retorna las instituciones de los `compas` y usamos un set para evitar entradas duplicadas."
]
]
},
},
{
{
"cell_type": "code",
"cell_type": "code",
"execution_count": 113,
"execution_count": 26,
"metadata": {},
"metadata": {},
"outputs": [],
"outputs": [],
"source": [
"source": [
...
@@ -281,10 +85,12 @@
...
@@ -281,10 +85,12 @@
" for matter in d:\n",
" for matter in d:\n",
" if d[matter][\"país\"] == pais: \n",
" if d[matter][\"país\"] == pais: \n",
" names.append(matter)\n",
" names.append(matter)\n",
" ## En caso de necesitar tabular de otra manera se deja así.\n",
" final = []\n",
" ## De lo contrario se puede hacer un solo loop.\n",
" for matter in names:\n",
" for matter in names:\n",
" print(d[matter])\n",
" datos = [d[matter][datum] for datum in d[matter]]\n",
" datos.append(matter)\n",
" final.append(datos)\n",
" return final\n",
" \n",
" \n",
"def edadMedia(d):\n",
"def edadMedia(d):\n",
" prom = []\n",
" prom = []\n",
...
@@ -299,28 +105,51 @@
...
@@ -299,28 +105,51 @@
" print(instituciones) "
" print(instituciones) "
]
]
},
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Para tabular importamos la librería `tabular` y definimos un array con los títulos. Para ello iteramos sobre las llaves de cualquier entrada de `compas`."
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
# Ejercicio 3
Con la función `newEntry` se puede poblar el diccionario.
Con la función `newEntry` se puede poblar el diccionario. No era parte del ejercicio pero me facilitó el proceso.
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.
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.
* La primera retorna una lista con los miembros del país seleccionado. Esta lista está lista para tabular.
* La segunda promedia las edades de todos en `compas`.
* La tercera retorna las instituciones de los `compas` y usamos un set para evitar entradas duplicadas.
%% Cell type:code id: tags:
%% Cell type:code id: tags:
``` python
``` python
defsortPais(d,pais):
defsortPais(d,pais):
names=[]
names=[]
formatterind:
formatterind:
ifd[matter]["país"]==pais:
ifd[matter]["país"]==pais:
names.append(matter)
names.append(matter)
## En caso de necesitar tabular de otra manera se deja así.
final=[]
## De lo contrario se puede hacer un solo loop.
formatterinnames:
formatterinnames:
print(d[matter])
datos=[d[matter][datum]fordatumind[matter]]
datos.append(matter)
final.append(datos)
returnfinal
defedadMedia(d):
defedadMedia(d):
prom=[]
prom=[]
formatterind:
formatterind:
prom.append(float(compas[matter]["edad"]))
prom.append(float(compas[matter]["edad"]))
print(sum(prom)/len(prom))
print(sum(prom)/len(prom))
definstit(d):
definstit(d):
instituciones=set()
instituciones=set()
formatterind:
formatterind:
instituciones.add(compas[matter]["institución"])
instituciones.add(compas[matter]["institución"])
print(instituciones)
print(instituciones)
```
```
%% Cell type:markdown id: tags:
Para tabular importamos la librería `tabular` y definimos un array con los títulos. Para ello iteramos sobre las llaves de cualquier entrada de `compas`.
