Ejercicio: 1Eva_IIT2017_T3 Venta combustibles

Propuesta de solución en Python:

Se usan datos de prueba para probar la ejecución del algoritmo por cada literal. En el bloque de ingreso se pide solo un tipo de combustible (literal a) y una ciudad (literal b).

Se usa vector.index(dato) para ubicar la posición de un dato en el vector.

# literal a
cual     = tipoGasolina.index(untipo)
cantidad = venta[cual,:]
prom_anual =  np.sum(cantidad)/m
menosprom  = []
for c in range(0,m,1):
    if (cantidad[c]<prom_anual):
        menosprom.append(gasolinera[c])

Como algunas respuestas tienen un número indeterminado de elementos se usan listas, al inicio vacías. Revise el uso de np.concatenate() para hacerlo con arreglos.

---

Algoritmo en Python

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2017_T3 Venta combustibles
import numpy as np

# INGRESO
venta = np.array([
    [ 239034,  678493,  896321,   32438,  554213],
    [4568321, 6745634, 9754008, 3242342, 3456123],
    [ 234773,   56743,  123678,    4783,   90874],
    [  45672,   45212,   90781,    3904,   90431]])

tipoGasolina = np.array(['Regular',
                         'Extra',
                         'Super',
                         'Premium'])

gasolinera  = np.array(['Primax Alborada',
                        'PS Los Ríos',
                        'Móbil Cumbayá',
                        'Lutexa Cia Ltda',
                        'PS Remigio Crespo'])

distrito = np.array(['distrito1',
                     'distrito2',
                     'distrito1',
                     'distrito2',
                     'distrito4'])

ciudad =  np.array(['Guayaquil',
                    'Babahoyo',
                    'Quito',
                    'Guayaquil',
                    'Cuenca'])

meta = 5000000

untipo    = input('un tipo de gasolina: ')
unaciudad = input('una ciudad: ')

# PROCEDIMIENTO
tipoGasolina = list(tipoGasolina)
gasolinera   = list(gasolinera)
distrito = list(distrito)
ciudad   = list(ciudad)

tamano = np.shape(venta)
n = tamano[0]
m = tamano[1]

# literal a
cual     = tipoGasolina.index(untipo)
cantidad = venta[cual,:]
prom_anual =  np.sum(cantidad)/m
menosprom  = []
for c in range(0,m,1):
    if (cantidad[c]<prom_anual):
        menosprom.append(gasolinera[c])

# literal b
cual  = ciudad.index(unaciudad)
anual = np.sum(venta, axis=0)
menosciudad = []
for c in range(0,m,1):
    if (ciudad[c] == unaciudad  and anual[c]<meta):
        menosciudad.append(gasolinera[c])
cuantas = len(menosciudad)

# literal c
cual = tipoGasolina.index('Premium')
cantidad = venta[cual,:]
nombres = []
valores = []
for c in range(0,m,1):
    if (distrito[c] == 'distrito2'):
        nombres.append(ciudad[c])
        valores.append(cantidad[c])

k = len(nombres)
mayor = np.argmax(np.array(valores))
mejorendistrito = nombres[mayor]

# SALIDA
print('literal a')
print('con menos ventas anuales que promedio: ')
print(menosprom)

print('literal b')
print('cantidad de estaciones de ' + unaciudad + ': ')
print(cuantas)

print('literal c')
print(nombres)
print(valores)
print(mejorendistrito)

Resultado del algoritmo

un tipo de gasolina: Regular
una ciudad: Guayaquil
literal a
con menos ventas anuales que promedio: 
['Primax Alborada', 'Lutexa Cia Ltda']
literal b
cantidad de estaciones de Guayaquil: 
1
literal c
['Babahoyo', 'Guayaquil']
[45212, 3904]
Babahoyo
>>> 

Ejercicio: 1Eva_IIT2017_T1 Taller de juguetes en polo norte

Propuesta de solución en Python:

Los tiempos para finalizar las tareas se obtienen como la suma de los tiempos de inicio mas los tiempos de duración.

Para realizar la mayor cantidad de tareas, se usan los tiempos para finalizarlas, buscando la posición en la lista de la mayor. Al encontrarla se puede establecer el orden.

El proceso se repite para el resto de tareas. Para que no se utilice la primera encontrada se elimina de la lista asignando el tiempo final con cero.

---

Algoritmo en Python

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2017_T1 Taller de juguetes en polo norte
import numpy as np

# INGRESO
tareas = ['pintar soldados',
          'hornear galletas',
          'armar muñecos',
          'cortar papel de regalo']
inicio   = [ 678, 200, 240, 423]
duracion = [ 300, 800, 456, 112]

# PROCEDIMIENTO
n = len(tareas)

# tiempo finaliza tarea
final = np.zeros(n,dtype=int)
i = 0
while not(i>=n):
    final[i] = inicio[i] + duracion[i]
    i = i + 1

# Determina el orden
finaliza = np.copy(final)
orden = np.zeros(n,dtype = int)
j = 0
while not(j>=n):
    
    mayor = 0
    i = 1
    while not(i>=n):
        if (final[i]>final[mayor]):
            mayor = i
        i = i + 1
    
    orden[j] = mayor
    final[mayor] = 0
    j = j + 1
    
# dias de trabajo
dia  = np.zeros(n,dtype = int)
cual = 1
suma = 0
j = 0
while not(j>=n):
    suma = suma + finaliza[j]
    if (suma>=1440):
        cual = cual + 1
        suma = finaliza[j]
    dia[j] = cual
    j = j + 1
   
# SALIDA
print('finaliza')
print(finaliza)

print('Tareas del dia')
s = 0
i = 0
while not(i>=n):
    cual = orden[i]
    s = s + finaliza[cual]
    print(i, cual, tareas[cual], s, dia[i])
    i = i + 1

Resultado del algoritmo

finaliza
[ 978 1000  696  535]
Tareas del dia
0 1 hornear galletas 1000 1
1 0 pintar soldados 1978 2
2 2 armar muñecos 2674 3
3 3 cortar papel de regalo 3209 3
>>> 

Ejercicio: 1Eva_IIT2017_T2 Texto de Examen de sangre

Propuesta de solución en Python:

Para simplificar el ejercicio, se supondrá que el resultado corresponde al texto del ejemplo en el enunciado:

resultado = "Resultado de Laboratorio 'Su Salud' Nombre del paciente: José Aimas E-mail del paciente: jose.aimas@gmail.com Resultados del laboratorio: INR 1.25 segundos BGT 180.12 mmol/dL HGB 13 g/dL ESR 3.2 mm/hora RBC 4000024.2 cel/ul TA 1.5 ng/dL WBC 123233.23 cel/uL. Los valores de éste informe no representan un diagnóstico. Firma médico responsable: Dr. Juan Pozo"

El texto se analiza separando las partes usando los espacios '  '.

>>> partes = resultado.split(' ')
>>> partes
['Resultado', 'de', 'Laboratorio', "'Su", "Salud'",
 'Nombre', 'del', 'paciente:', 'José', 'Aimas',
...
]
>>> 

Se analiza cada una de las partes, considerando que los «indicadores buscados» tienen todas las letras en mayúsculas a diferencia del resto de partes o palabras. Por lo que se compara la conversión de la parte en mayúsculas y su forma original o sinconvertir, si son iguales se encontró un indicador.
Considere que si la parte es numérica, no se afecta al convertir en mayúscula.

>>> i=0
>>> mayusculas = partes[i].upper()
>>> sinconvertir = partes[i]
>>> mayusculas
'RESULTADO'
>>> sinconvertir
'Resultado'
>>> mayusculas == sinconvertir
False
>>> 

Al encontrar un indicador, se lo separa en otra lista de solo indicadores.

---

Algoritmo en Python

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2017_T2 Examen de sangre
# Tarea: Encontrar nombre del médico

# INGRESO
resultado = "Resultado de Laboratorio 'Su Salud' Nombre del paciente: José Aimas E-mail del paciente: jose.aimas@gmail.com Resultados del laboratorio: INR 1.25 segundos BGT 180.12 mmol/dL HGB 13 g/dL ESR 3.2 mm/hora RBC 4000024.2 cel/ul TA 1.5 ng/dL WBC 123233.23 cel/uL. Los valores de éste informe no representan un diagnóstico. Firma médico responsable: Dr. Juan Pozo"

# PROCEDIMIENTO
partes = resultado.split(' ')
n = len(partes)

# Encontrar indicadores
numero = '0123456789'
indicador = []
i = 0
while not(i>=n):
    mayusculas   = partes[i].upper()
    sinconvertir = partes[i]
    unapalabra   = partes[i]
    unaletra     = unapalabra[0]
    if (mayusculas==sinconvertir and not(unaletra in numero)):
        indicador.append(partes[i])
    i = i + 1
m = len(indicador)

# Busca por indicadores
valor  = []
unidad = []
k = 0
while not(k>=m):
    i = 0
    while not(i>=n):
        if (partes[i]==indicador[k]):
            valor.append(partes[i+1])
            unidad.append(partes[i+2])
        i = i + 1
    k = k + 1

# SALIDA
print('INFORME DE LABORATORIO')
print('**********************')
i = 0
while not(i>=m):
    print(indicador[i],valor[i],unidad[i])
    i = i + 1

Resultado del algoritmo

INFORME DE LABORATORIO
**********************
INR 1.25 segundos
BGT 180.12 mmol/dL
HGB 13 g/dL
ESR 3.2 mm/hora
RBC 4000024.2 cel/ul
TA 1.5 ng/dL
WBC 123233.23 cel/uL.
>>> 

Ejercicio: 3Eva_IT2017_T1 Archivos de notas por semestre

Propuesta de solución en Python:

Para la prueba del algoritmo, se requiere los archivos:

notas-2015-I.csv

notas-2013-II.csv

Algoritmo en Python

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IT2017_T1 Archivos de notas por semestre
# Tarea: una vez comprendido los pasos, 
#        simplificar de ser posible
import numpy as np

def academico(narchivos):
    notas = {}
    n = len(narchivos)
    for i in range(0,n,1):
        archivo = open(narchivos[i],'r')

        # semestre en el nombre
        nombre = narchivos[i]
        partes = nombre.split('.')
        semestre = partes[0][6:]

        # Datos del archivo
        linea = archivo.readline()
        while not(linea==''):
            linea   = linea.strip('\n')
            partes  = linea.split(',')
            quien   = int(partes[0])
            materia = partes[1]
            nota1   = int(partes[2])
            nota2   = int(partes[3])
            nota3   = int(partes[4])
            estado  = partes[5]
            califica = (materia,nota1,nota2,
                        nota3,estado)

            # Revisar estudiante creado
            estudiantes = notas.keys()
            if not(quien in estudiantes):
                notas[quien] = {semestre:[califica]}
            else:
                cuando = notas[quien].keys()
                if (semestre in cuando):
                    notas[quien][semestre].append(califica)
                else:
                    notas[quien][semestre] = [califica]

            linea = archivo.readline()
        archivo.close()
    return(notas)

def semestres(notas,matricula):
    estudiantes = notas.keys()
    cuando = ()
    if (matricula in estudiantes):
        cuando = notas[matricula].keys()
    cuando = tuple(cuando)
    return(cuando)

def nota_academico(notas,matricula,materia):
    califica = []
    estudiantes = notas.keys()
    # Desarrollar tarea
        
    return(nota_final)

def mas_aprobados(notas,semestre):
    # Separa dictadas y aprobadas en el semestre
    dictadas = []
    estudiantes = notas.keys()
    for quien in estudiantes:
        cuando = notas[quien].keys()
        if (semestre in cuando):
            registradas = notas[quien][semestre]
            n = len(registradas)
            for i in range(0,n,1):
                if (registradas[i][4] == 'AP'):
                    dictadas.append(registradas[i][0])

    # Cuenta las repetidas
    m = len(dictadas)
    lista = list(set(dictadas))
    conteo = {}
    for j in range(0,m,1):
        una = dictadas[j]
        if (una in conteo):
            conteo[una] = conteo[una]+1
        else:
            conteo[una] = 1

    # busca la mas aprobada
    mejor = ''
    if (len(conteo)>0):
        llaves  = list(conteo.keys())
        valores = np.array(conteo.values())
        mejor   = llaves[np.argmax(valores)]
    return(mejor)

# PROGRAMA
# INGRESO /siguiendo ejemplo de examen
narchivos = ['notas-2015-I.csv',
           'notas-2013-II.csv']
matricula = 201321454
materia   = 'Fundamentos de Programación'
semestre  = '2015-I'

# PROCEDIMIENTO
notas = academico(narchivos)
semestres  = semestres(notas, matricula)
nota_final = nota_academico(notas, matricula, materia)
alto_AP = mas_aprobados(notas, semestre)

# SALIDA
print('las notas son: ')
print(notas)
print('--- para '+str(matricula) + ': ')
print('semestres que estudió: ',semestres)
print('notas final para '+materia+': ',nota_final)
print('--- En el semestre '+semestre + ': ' )
print('la materia con alto indice de aprobación es: ',
      alto_AP)

Ejercicio: 3Eva_IT2017_T2 Huracanes en Atlantico Norte

Propuesta de solución en Python:

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IT2017_T2 Huracanes en Atlantico Norte
# Supone que el numero de columnas de M
# Es igual al numero de nombres en huracanes

import numpy as np

def categoriza(M):
    tamano = np.shape(M)
    n = tamano[0]
    m = tamano[1]
    categoria = np.ones(m, dtype=int)
    for j in range(0,m,1):
        vv = M[2,j]
        if (vv>=100 and vv=150 and vv=200 and vv250):
            categoria[j]=5
    return(categoria)

def total_marejada(M,cat):
    categoria = categoriza(M)
    
    tamano = np.shape(M)
    n = tamano[0]
    m = tamano[1]

    marejadas = np.zeros(6,dtype=float)
    for j in range(0,m,1):
        k = categoria[j]
        marejadas[k] = marejadas[k]+M[4,j]
    totaluna = marejadas[cat]
    return(totaluna)

def indices_anio(huracanes,anio):
    # Supone que cantidad de huracanes
    # es igual a columnas de matriz
    cuales  = huracanes.keys()
    indices = {}
    a = 0
    b = -1
    for cada in cuales:
        m = len(huracanes[cada])
        a = b + 1
        b = a + m-1
        indices[cada] = [a,b]
    return(indices[anio])

def velocidad_superior(M,huracanes,anio):
    cual   = indices_anio(huracanes,anio)
    desde  = cual[0]
    hasta  = cual[1]
    vector = M[0,desde:hasta+1]
    promedio = np.mean(vector)
    cuantos = 0
    for valor in vector:
        if (valor>promedio):
            cuantos = cuantos + 1
    return(cuantos)

def ACE(M,huracanes,anio):
    cual   = indices_anio(huracanes,anio)
    desde  = cual[0]
    hasta  = cual[1]
    vector = M[0,desde:hasta+1]
    liberada = 0
    for valor in vector:
        liberada = liberada + valor**2
    liberada = liberada*(10**(-4))
    return(liberada)

def lluvia(M, huracanes, nombre_huracan,anio):
    nombres = huracanes[anio]
    nombres = list(nombres)
    donde   = nombres.index(nombre_huracan)
    cual  = indices_anio(huracanes,anio)
    desde = cual[0]
    hasta = cual[1]
    cantidad = M[3,desde+donde]
    return(cantidad)

# PROGRAMA ------------------------
import numpy as np

M = np.array([[20, 30, 19, 15, 18],
              [89,195,120,150,240],
              [65,165,100,110,200],
              [30, 49, 35, 89, 67],
              [ 5, 18,  1,  2,  5]]
             )
# 2015:('Ana','Kate'), # No usado para el ejemplo (CONFUSO)
huracanes = {2016:('Alex', 'Otto'),
             2017:('Ariene', 'Harvey','Irma'),
             }
cat = 2
anio = 2017
nombre_huracan = 'Harvey'

# PROCEDIMIENTO
categoria = categoriza(M)
marejadas = total_marejada(M,cat)
indices   = indices_anio(huracanes,anio)
vel_superior = velocidad_superior(M,huracanes,anio)
energia = ACE(M,huracanes,anio)
llovio  = lluvia(M, huracanes, nombre_huracan,anio)

# SALIDA
print(M)
print(huracanes)
print('---')
print('categorias: ', categoria)
print('Marejadas cat['+str(cat)+']: ', marejadas)
print('indices: ', indices)
print('velocidad superior: ', vel_superior)
print('Energia liberada: ',energia)
print('lluvia en mm: ', llovio)

Ejercicio: 1Eva_IT2017_T1 Palabras puntaje

Propuesta de solución en Python, revisar tema indicado como tarea:

Para iniciar el algoritmo se presenta un ejemplo busca como resultado: mostrar cada palabra y su puntaje.

Al final se muestra la palabra que obtuvo mayor puntaje.

palabra, puntaje:
CAS*A* 6
S*ASTR*E* 6
R*EY* 6
A*ZOTE* 14
Mayor puntaje: 
A*ZOTE* 14
>>> 

Algoritmo en Python

En el bloque de ingreso se ha optado por incluir las palabras del ejercicio del enunciado.

Para simplificar la identificación de las letras se convierten todas a mayusculas en caso que el usuario las escriba en minúsculas. Se utiliza un contador de «puntos» por cada «palabra«.

Luego se procesa cada palabra, analizando cada letra para encontrar su puntaje equivalente.

# 1ra Evaluación I Término 2017
# Tema 1. puntaje de palabras
# Tarea: considere los '*'como doble puntaje
#        para letra anterior
import numpy as np

# INGRESO
# variaspalabras = input('Analizar: ')
variaspalabras ='CAS*A*,S*ASTR*E*,R*EY*,A*ZOTE*'

# PROCEDIMIENTO
abecedario = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
equivale = [1,3,3,2,1,4,2,4,1,9,5,1,3,1,1,3,
            10,1,1,1,1,4,4,9,4,10]

# unifica a mayúsculas
variaspalabras = variaspalabras.upper()

# separa las palabras por ','
palabras = variaspalabras.split(',')

n = len(palabras)

# arreglo de puntos por cada palabra
puntos = np.zeros(n,dtype=int)

i = 0
while (i<n):
    unapalabra = palabras[i]
    m = len(unapalabra)

    # Analiza palabra, letra por letra
    j = 0
    while (j<m):
        letra = unapalabra[j]
        if (letra in abecedario):
            donde = abecedario.index(letra)
            puntos[i] = puntos[i]+equivale[donde]
        j = j+1 # siguiente letra
    
    i = i+1  #siguiente palabra

# encuentra posición del máximo puntaje
cual = np.argmax(puntos)

# SALIDA
print('palabra, puntaje: ')
i = 0
while (i<n):
    print(palabras[i],puntos[i])
    i = i+1

print('Mayor puntaje: ')
print(palabras[cual],puntos[cual])

Ejercicio: 1Eva_IT2017_T2 suscriptores de youtubers

Propuesta de solución en Python, procedimiento desarrollado por literal

Algoritmo en Python

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IT2017_T2 suscriptores de youtubers
import numpy as np

# INGRESO
matriz = np.array([
    [  24771906, 5477807839,  21900,   262800],
    [ 184551280, 7046108694,  45500,   546000],
    [     76493,     798122,     36,      430],
    [    133538,   21104851,    156,     1900],
    [  18554394, 1967543913,   6700,    80000],
    [  12548964, 2034702069,  12200,    12200]])

espana  = ['elrubiosOMG','VEGETTA777']
ecuador = ['enchufetvLIVE','Kreizivoy']
mexico  = ['Yuya','Werevertumorro']

# PROCEDIMIENTO

# Literal a) ********
tamano = np.shape(matriz)
n = tamano[0]
m = tamano[1]

rentabilidad = np.zeros(n,dtype=float)
f = 0
while not(f>=n):
    rentabilidad[f] = matriz[f,m-1]/matriz[f,0]
    f = f + 1

cualganamas = np.argmax(rentabilidad)

todos = espana + ecuador + mexico
quienganamas = todos[cualganamas]

dondees = 'español'
if quienganamas in ecuador:
    dondees = 'ecuatoriano'
if quienganamas in mexico:
    dondees = 'mexicano'

# SALIDA
print('literal a: ')
print(rentabilidad)
print('el mas rentable es: ',cualganamas)
print('quien es mas rentable: ',quienganamas)
print('del pais: ', dondees)


# Literal b: ********
# Solo trabajo con espana
nsp = len(espana)
datoespana = matriz[0:nsp,:]
rentasp = datoespana[:,m-1]/datoespana[:,0]
cualsp  = np.argmax(rentasp)
quiensp = espana[cualsp]

# SALIDA b)
print('para espana: ')
print(cualsp)
print(quiensp)

# literal c) ********
ecmx=matriz[nsp:,0]
popecmx    = np.argmax(ecmx)
cuantoecmx = np.max(ecmx)

ganan = 0
suscritosp = matriz[0:nsp,0]
f = 0
while not(f>=nsp):
    if (suscritosp[f]>cuantoecmx):
        ganan = ganan + 1
    f = f + 1
    
# SALIDA c)
print('tienen mas en espana: ',ganan)

# literal d) ********
reproduce = matriz[:,1]
cuantosrp = 0
totalrp = 0
f = 0
while not(f>=n):
    if (reproduce[f]>1000000):
        cuantosrp = cuantosrp+1
        totalrp   = totalrp + reproduce[f]
    f = f + 1
promrp = totalrp/cuantosrp

# SALIDA d)
print('promedio mas un millon: ',promrp)
a=len(espana)
rentaec = rentabilidad[a:a+len(ecuador)]

resultado del algoritmo

literal a: 
[0.01060879 0.00295853 0.00562143 0.01422816 0.00431165 0.00097219]
el mas rentable es:  3
quien es mas rentable:  Kreizivoy
del pais:  ecuatoriano
para espana: 
0
elrubiosOMG
tienen mas en espana:  2
promedio mas un millon:  3309453473.2
>>> 

Ejercicio: 1Eva_IIT2016_T1 Analiza una frase por vocales y consonantes

Propuesta de solución en Python, para:

texto = 'Algunas Palabras pArA contar en un programa con algo de Python'
Igual número de consonantes y vocales: 
5
>>>

Para facilitar el trabajo con el texto, se convierten todas las letras a mayúsculas upper().

En principio, se considera que las palabras se separan solo por espacios '  ', separando las palabras en sus partes usando la instrucción split('  '). Queda como tarea considerar otras formas de separar palabras con ',' y '.'

>>> partes
['ALGUNAS', 'PALABRAS', 'PARA', 'CONTAR',
 'EN', 'UN', 'PROGRAMA', 'CON', 'ALGO',
 'DE', 'PYTHON']
>>>

Las vocales y consonantes se referencian con los caracteres en mayúsculas.

El análisis se realiza por cada palabra, luego por cada letra, realizando el conteo de cada vocal y consonante.

>>> j=0
>>> palabra=partes[j]
>>> palabra
'ALGUNAS'
>>> 

El resultado se obtiene al comparar los contadores de vocal y consonante.

---

Algoritmo en Python

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2016_T1 Analiza frase por vocales y consonantes
# Solución propuesta: edelros@espol.edu.ec

# INGRESO
# texto = input('frase: ')
texto = 'Algunas Palabras pArA contar en un programa con algo de Python'

# PROCEDIMIENTO

# unificando todo mayúsculas
texto = texto.upper()

# Separa palabras por espacios
# Tarea: considerar ',' y '.'
partes = texto.split(' ')
m = len(partes)

vocales = 'AEIOU'
consonantes = 'BCDFGHJKLMNPQRSTVWXYZ'

cuenta = 0
j = 0
while not(j>=m):
    palabra = partes[j]

    # Analiza una palabra
    n = len(palabra)
    cvocal = 0  # contador vocal
    cconso = 0

    i=0
    while not(i>=n):
        letra = palabra[i]
        if letra in vocales:
            cvocal = cvocal + 1
        else:
            cconso = cconso + 1
        i = i + 1

    if (cvocal==cconso):
        cuenta = cuenta + 1
    j = j + 1

# SALIDA
print('Igual número de consonantes y vocales: ')
print(cuenta)

Ejercicio: 2Eva_IIT2016_T2 País destino para jubilados extranjeros

Propuesta de solución en Python:

requiere usar el archivo: destinosdatos.txt

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2016_T2 País destino para jubilados extranjeros

def cargarDatos(nomFile):
    datos = {}
    archivo = open(nomFile, 'r')
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        
        ciu = partes[0]
        met = partes[1]
        val = float(partes[2])
        
        if not(ciu in datos):
            datos[ciu] = {met:val}
        else:
            datos[ciu][met]= val
        linea = archivo.readline()
        
    archivo.close()
    return(datos)

def metricaPais(datos, paises):
    promedios = {}
    for unpais in paises:
        totalcanasta = 0
        totaltemperatura = 0
        ciudades = paises[unpais]
        
        for unaciudad in ciudades:
            unacanasta = datos[unaciudad]['canastaBasica']
            totalcanasta = totalcanasta + unacanasta
            unatemp = datos[unaciudad]['temperatura']
            totaltemperatura = totaltemperatura + unatemp

        # los promedios son por pais
        promediocanasta     = totalcanasta/len(ciudades)
        promediotemperatura = totaltemperatura/len(ciudades)
        promedios[unpais] = {'canastaBasica': promediocanasta,
                             'temperatura': promediotemperatura}  
    return(promedios)

def generaPaises(promedios, metrica, minimo, maximo):
    narchivo = 'cumplencon.csv'
    archivo  = open(narchivo, 'w')
    
    for unpais in promedios:
        valor = promedios[unpais][metrica]
        if (valor>=minimo and valor<=maximo):
            linea = unpais +'\n'
            archivo.write(linea)
    archivo.close
    
    mensaje = 'resultados en archivo'
    return(mensaje)


# PROGRAMA Prueba
# INGRESO
paises = {'Ecuador':{'Cuenca','Guayaquil'},
          'Colombia':{'Bogotá'}}

nomFile = 'destinosdatos.txt'

metrica = input('cual metrica: ')
minimo  = float(input('minimo: '))
maximo  = float(input('maximo: '))

# PROCEDIMIENTO
tabla = cargarDatos(nomFile)
promedios = metricaPais(tabla, paises)
cualescumplen = generaPaises(promedios, metrica, minimo, maximo)

# SALIDA
print('tabla de datos: ')
print(tabla)
print('paises')
print(paises)
print('promedios de características')
print(promedios)
print('paises de interes para el jubilado, en archivo')

Ejercicio: 1Eva_IT2016_T2 historial de visitas web

literal a. Se obtiene un registro de los sitios visitados, para luego separar sus partes entre empleado|sitio|duracion.

Para los sitios que no son de trabajo se usa una lista llamada ocio. Si el sitio visitado no se encuentra en trabajo, se añade a la lista ocio. Se considera revisar que la lista no tenga elementos repetidos

# a) sitios que no son de trabajo
ocio = []
n = len(visitados)
i = 0
while not(i>=n):
    registro = visitados[i]
    partes = registro.split('|')
    sitio  = partes[1]
    if not(sitio in trabajo):
        if not(sitio in ocio):
            ocio.append(sitio)
    i = i + 1

literal b. Par contabilizar el tiempo por empleado se acumula en una lista los tiempos de navegación, usando la posición del empleado en la lista obtenida con la instrucción empleados.index(quien)

# b) tiempo de internet/empleado
m = len(empleados)
tiempo = np.zeros(m,dtype=int)

n = len(visitados)
i = 0
while not(i>=n):
    registro = visitados[i]
    partes = registro.split('|')
    quien  = partes[0]
    indice = empleados.index(quien)
    cuanto = int(partes[2])
    tiempo[indice] = tiempo[indice] + cuanto
    i = i + 1

Se procede de forma semejante para obtener una tabla de tiempos por sitio.

Una respuesta que se pude obtener de la tabla anterior es la búsqueda del empleado más ocioso, el que ha usado más tiempo en sitios de ocio. (tema 3, literal f)

---

Algoritmo en Python

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IT2016_T2 historial de visitas web
import numpy as np

# INGRESO
visitados = [ 'maria2|www.facebook.com|160',
              'xavi7|www.eluniverso.com|50',
              'jose15|www.sri.gob.ec|30',
              'maria2|www.twitter.com|30',
              'xavi7|www.inec.gob.ec|10',
              'maria2|www.espol.edu.ec|50',
              'jose15|www.sri.gob.ec|120',
              'xavi7|www.sri.gob.ec|20',
              'maria2|www.twitter.com|20',]
empleados = ['maria2',
             'jose15',
             'xavi7']
trabajo = ['www.espol.edu.ec',
           'www.inec.gob.ec',
           'www.sri.gob.ec']

# PROCEDIMIENTO

# a) sitios que no son de trabajo
ocio = []
n = len(visitados)
i = 0
while not(i>=n):
    registro = visitados[i]
    partes = registro.split('|')
    sitio  = partes[1]
    if not(sitio in trabajo):
        if not(sitio in ocio):
            ocio.append(sitio)
    i = i + 1

# b) tiempo de internet/empleado
m = len(empleados)
tiempo = np.zeros(m,dtype=int)

n = len(visitados)
i = 0
while not(i>=n):
    registro = visitados[i]
    partes = registro.split('|')
    quien  = partes[0]
    indice = empleados.index(quien)
    cuanto = int(partes[2])
    tiempo[indice] = tiempo[indice] + cuanto
    i = i + 1

# b) tiempo de internet por empleado/sitio. matrices
k = len(visitados)
n = len(empleados)
todositio = trabajo + ocio
m = len(todositio)
tabla = np.zeros(shape=(n,m), dtype=int)

i = 0
while not(i>=k):
    registro = visitados[i]
    partes = registro.split('|')
    quien  = partes[0]
    fila   = empleados.index(quien)
    donde  = partes[1]
    columna = todositio.index(donde)
    cuanto = int(partes[2])
    tabla[fila,columna] = tabla[fila,columna] + cuanto
    i = i+1

# Tema 3. f)
# empleado es mas ocioso
parte = tabla[:,len(trabajo):]
ocioempleado = np.sum(parte, axis =1)
masocioso = np.argmax(ocioempleado)
quien = empleados[masocioso]

# SALIDA
print('sitios de ocio: ')
print(ocio)
print('tiempos por empleado: ')
print(tiempo)
print('tabla de tiempos: ')
print(tabla)
print('empleado mas ocioso: ', quien) 

resultado del algoritmo

sitios de ocio: 
['www.facebook.com', 'www.eluniverso.com', 'www.twitter.com']
tiempos por empleado: 
[260 150  80]
tabla de tiempos: 
[[ 50   0   0 160   0  50]
 [  0   0 150   0   0   0]
 [  0  10  20   0  50   0]]
empleado mas ocioso:  maria2
>>>