Autor: Edison Del Rosario

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.

Instrucciones 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.

# 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

# 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)