Commit 4e6df2c9 authored by David Ramos Salamanca's avatar David Ramos Salamanca
Browse files

just missing some more personal info

parent a25d5e78
......@@ -14269,7 +14269,7 @@ 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>Escriba un programa en python que acepte una lista de palabras separadas por guiones e imprima de vuelta las mismas palabras, sin repetición y nuevamente separadas por guiones,después de ordenarlas alfabéticamente.</p>
<p><strong>Escriba un programa en python que acepte una lista de palabras separadas por guiones e imprima de vuelta las mismas palabras, sin repetición y nuevamente separadas por guiones,después de ordenarlas alfabéticamente.</strong></p>
<p><strong>Ejemplo de entrada:</strong> naranja-avión-melodía-tupla-avión</p>
<p><strong>Salida esperada:</strong> avión-melodía-naranja-tupla</p>
 
......
%% Cell type:markdown id: tags:
# David Ramos - UIS
%% Cell type:markdown id: tags:
## Problema: Lista de palabras
%% Cell type:markdown id: tags:
Escriba un programa en python que acepte una lista de palabras separadas por guiones e imprima de vuelta las mismas palabras, sin repetición y nuevamente separadas por guiones,después de ordenarlas alfabéticamente.
**Escriba un programa en python que acepte una lista de palabras separadas por guiones e imprima de vuelta las mismas palabras, sin repetición y nuevamente separadas por guiones,después de ordenarlas alfabéticamente.**
**Ejemplo de entrada:** naranja-avión-melodía-tupla-avión
**Salida esperada:** avión-melodía-naranja-tupla
%% Cell type:markdown id: tags:
## Solución
%% Cell type:markdown id: tags:
Primero se adquieren las palabras
%% Cell type:code id: tags:
``` python
disordered_words = input('Escriba una lista de palabras separadas or guíones: ') # input() convierte todo input a string
```
%% Output
Escriba una lista de palabras separadas or guíones: ola-hola-ala
%% Cell type:code id: tags:
``` python
disordered_words
```
%% Output
'ola-hola-ala'
%% Cell type:markdown id: tags:
La estrategia es crear una lista de palabras a partir del string. La cual que se puede organizar fácilmente con métodos de las listas para luego devolver como un solo string.
%% Cell type:markdown id: tags:
Para crear la lista de palabras se irán añadiendo los caracteres del string en una variable hasta encontrar un guión, en cuyo caso se agrega el contenido de la variable a una lista y se resetea la variable donde se guardan los caracteres para almacenar la siguiente palabra.
%% Cell type:code id: tags:
``` python
mywords = [] # en esta lista se almacenarán las palabras
word = '' # string vacío para almacenar los caracteres de cada palabra
for char in disordered_words: # iterando sobre los caracteres del string
if char != '-': # si el caracter no es - se añade a la palabra
word += char
else: # si el caracter es -, se añade la palabra a la lista y vacía la palabra
mywords.append(word)
word = ''
mywords.append(word) # añadiendo la última palabra
```
%% Cell type:code id: tags:
``` python
mywords
```
%% Output
['ola', 'hola', 'ala']
%% Cell type:markdown id: tags:
Usando los conjuntos se eliminan duplicados y luego se organiza usando *sorted()*
%% Cell type:code id: tags:
``` python
sorted(list(set(mywords))) #se orgniza alfabéticamente y eliminan repeticiones
```
%% Output
['ala', 'hola', 'ola']
%% Cell type:code id: tags:
``` python
mywords
```
%% Output
['ola', 'hola', 'ala']
%% Cell type:markdown id: tags:
Finalmente se usa la función *join()* de python para unir en un string las palabras. La lista que se unió fue una en la cual todas las palabras finalizan con un guión excepto la última.
%% Cell type:code id: tags:
``` python
ordered_words = ''.join([word + '-' for word in mywords])[:-1]
```
%% Cell type:code id: tags:
``` python
ordered_words
```
%% Output
'ola-hola-ala'
%% Cell type:markdown id: tags:
Organizando todo en una función
%% Cell type:code id: tags:
``` python
def word_orderer(disordered_words):
"""Sort alphabetically a string with a list of words separated by a hyphen eliminating repetitions."""
mywords = [] # en esta lista se almacenarán las palabras
word = '' # string vacío para almacenar los caracteres de cada palabra
for char in disordered_words: # iterando sobre los caracteres del string
if char != '-': # si el caracter no es - se añade a la palabra
word += char
else: # si el caracter es -, se añade la palabra a la lista y vacía la palabra
mywords.append(word)
word = ''
mywords.append(word) # añadiendo la última palabra
mywords = sorted(list(set(mywords))) # se organiza alfabéticamente y eliminan repeticiones
return ''.join([word + '-' for word in mywords])[:-1]
```
%% Cell type:code id: tags:
``` python
word_orderer('naranja-avión-melodía-tupla-avión')
```
%% Output
'avión-melodía-naranja-tupla'
......
......@@ -14269,7 +14269,7 @@ 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>Escriba una rutina en python que reciba como entrada un número entero, <em>n</em>, e imprima los números en la <em>n-ésima</em> fila del triángulo de Pascal. El programa debe verificar si el número <em>n</em> es entero, o arrojar un mensaje informando que ha habido un error del usuario en caso contrario.</p>
<p><strong>Escriba una rutina en python que reciba como entrada un número entero, <em>n</em>, e imprima los números en la <em>n-ésima</em> fila del triángulo de Pascal. El programa debe verificar si el número <em>n</em> es entero, o arrojar un mensaje informando que ha habido un error del usuario en caso contrario.</strong></p>
 
</div>
</div>
......@@ -14643,7 +14643,7 @@ $$ {n\choose k} = \frac{n!}{k!(n-k)!} .$$
</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>
<p><strong>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.</strong></p>
 
</div>
</div>
......
%% 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.
**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.
**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
......
This diff is collapsed.
%% Cell type:markdown id: tags:
# David Ramos - UIS
%% Cell type:markdown id: tags:
## Problema: Amigos congueros
%% Cell type:markdown id: tags:
**Entre en contacto con 10 estudiantes del curso de datos y 2 profesores o personal de soporte de LaConga, uno del curso de datos y otro de afuera, y consulte su nombre completo, su nombre de usuario en mattermost, edad, país de origen, ciudad donde residen, su especialidad científica, nombre del instituto en que estudian/laboran, y un hobbie o afición.**
%% Cell type:markdown id: tags:
## Solución (sin pandas)
%% Cell type:markdown id: tags:
Después de recopilar la información, creé un csv con todos los datos llamado *p_info.csv* y lo importé usando numpy.
%% Cell type:code id: tags:
``` python
import numpy as np
```
%% Cell type:code id: tags:
``` python
data = np.loadtxt('p_info.csv', delimiter = '\t', dtype='str', unpack=True)
```
%% Cell type:markdown id: tags:
La estrategia es crear una lista de *keys* que sean los usuarios de Mattermost y una lista de *values* que sean diccionarios con los otros datos.
%% Cell type:code id: tags:
``` python
users = data[0][1:] # lista de usuarios usando slicing
```
%% Cell type:code id: tags:
``` python
info = [{data[i][0]:data[i][j] for i in range(1,len(data[1:])+1)} for j in range(1,len(data[0][1:])+1)]
# lista de diccionarios usando un dic-comprehension dentro de una list-comprehension
```
%% Cell type:markdown id: tags:
Ahora, usando el constructor *dic()* y la función *zip()* se puede crear el diccionario deseado [[1](https://stackoverflow.com/questions/209840/how-do-i-convert-two-lists-into-a-dictionary)].
%% Cell type:code id: tags:
``` python
compas = dict(zip(users,info))
```
%% Cell type:markdown id: tags:
**Cree una función que reciba como entrada el diccionario y un país de origen, y retorne las informaciones completas de todas las personas de ese país, tabuladas en una forma fácil de entender.**
%% Cell type:code id: tags:
``` python
def bycountry(dic,country):
# obtengo los usuarios de las personas nacidas en ese pais
compatriots = [user for user in compas.keys() if compas[user]['pais'] == country]
# voy a imprimir verticalmente porque no cabe de manera horizontal
for compatriot in compatriots:
print('usuario: ' + compatriot)
for header in compas[compatriot].keys():
print(' \u25ba ' + header + ' : ' + compas[compatriot][header])
```
%% Cell type:code id: tags:
``` python
bycountry(compas,'Colombia')
```
%% Output
usuario: nicole
► nombre : Nicole
► apellido : Hernández
► pais : Colombia
► residencia : Bucaramanga
► edad : 23
► especialidad : análisis de imagen médica
► institucion : Universidad Industrial de Santander
► hobbie : dibujar
usuario: vargass
► nombre : Sasiri
► apellido : Vargas
► pais : Colombia
► residencia : Cali
► edad : 20
► especialidad : sistemas de reacción difusión unidimensionales
► institucion : Universidad del Valle
► hobbie : bailar
usuario: navasa
► nombre : Alfonso
► apellido : Navas
► pais : Colombia
► residencia : Bogotá
► edad : 24
► especialidad : física de sistemas complejos
► institucion : Universidad Nacional de Colombia
► hobbie : crossfit
%% Cell type:markdown id: tags:
**Busque una forma de calcular, a partir del diccionario, el promedio de edad de todas las personas en él, y una forma de mostrar todas las instituciones (sin repetición).**
%% Cell type:code id: tags:
``` python
def age_average(dic):
# recupero la edad de cada persona (convertida a un entero) usando una list-comprehension
ages = [int(value['edad']) for value in dic.values()]
# imprimo el promedio
return sum(ages)/len(ages)
```
%% Cell type:code id: tags:
``` python
age_average(compas)
```
%% Output
22.5
%% Cell type:code id: tags:
``` python
def institutions(dic):
# recupero las instituciones usando una list-comprehension y elimino duplicados convirtiéndola a un conjunto
insts = set([value['institucion'] for value in dic.values()])
# imprimo en distintas filas por claridad
for inst in insts:
print(inst)
```
%% Cell type:code id: tags:
``` python
institutions(compas)
```
%% Output
Universidad Nacional de Colombia
Universidad del Valle
Universidad Industrial de Santander
Universidad de los Andes
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment