Categoría: Solución 3ra Eva

Se usa un archivo de prueba: br-ur.csv

# 3Eva_IIT2018_T2 Jugadores Sudamericano Sub-20
# tema 2

def actualizaDiccionario(nomArchivo,dic):
    paises = list(dic.keys())
    archivo = open(nomArchivo,'r')
    encabezado = archivo.readline()
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        pais = partes[0]
        jugador = partes[1]
        if not(pais in paises):
            dic[pais]={jugador:{'TA':int(partes[2]),
                                'TR':int(partes[3]),
                                'Goles':int(partes[4]),
                                'Minutos':int(partes[5]),
                                'KM':float(partes[6])
                                  }
                       }
        else:
            jugadores = list(dic[pais].keys())
            if not(jugador in jugadores):
                dic[pais][jugador] = {'TA':int(partes[2]),
                                      'TR':int(partes[3]),
                                      'Goles':int(partes[4]),
                                      'Minutos':int(partes[5]),
                                      'KM':float(partes[6])
                                      }
            else:
                dic[pais][jugador]['TA'] = dic[pais][jugador]['TA'] + int(partes[2])
                dic[pais][jugador]['TR'] = dic[pais][jugador]['TR'] + int(partes[3])
                dic[pais][jugador]['Goles'] = dic[pais][jugador]['Goles'] + int(partes[4])
                dic[pais][jugador]['Minutos'] = dic[pais][jugador]['Minutos'] + int(partes[5]),
                dic[pais][jugador]['KM'] = dic[pais][jugador]['KM'] + float(partes[5])
        linea = archivo.readline()
    archivo.close()
    return(dic)

def buenDeportista(jugador,dic):
    cumple = 0
    paises = list(dic.keys())
    for pais in paises:
        jugadores = list(dic[pais].keys())
        if jugador in jugadores:
            tarjetas = dic[pais][jugador]['TA'] + dic[pais][jugador]['TR']
            transcurrido = dic[pais][jugador]['Minutos']
            registro = tarjetas/transcurrido
            if registro<(2/270):
                cumple=1
    return(cumple)

def jugadorAtleta(jugador,dic):
    cumple = 0
    paises = list(dic.keys())
    for pais in paises:
        jugadores = list(dic[pais].keys())
        total = 0
        for jugador in jugadores:
            total = total + dic[pais][jugador]['KM']
        promedio = total/len(jugadores)
        if jugador in jugadores:
            if dic[pais][jugador]['KM']>=promedio and dic[pais][jugador]['Goles']>=1:
                cumple = 1
    return(cumple)

def paisBuenasPraticas(pais,dic):
    cumple = 0
    paises = list(dic.keys())
    if pais in paises:
        jugadores = list(dic[pais].keys())
        k = len(jugadores)
        cuenta = 0
        for jugador in jugadores:
            cuenta = cuenta + buenDeportista(jugador, dic)
        if (k==cuenta):
            cumple = 1
    return(cumple)

# PROGRAMA
# INGRESO
L = ['br-ur.csv'] #,'ec-vn.csv']

# PROCEDIMIENTO
dic = {}
n = len(L)
i=0
while not(i>=n):
    nomArchivo = L[i]
    actualizaDiccionario(nomArchivo,dic)
    i = i+1

paises = list(dic.keys())
resultados = []
jugadoresatletas = []
for pais in paises:
    jugadores = list(dic[pais].keys())
    k = len(jugadores)
    cuenta = 0
    goles = 0
    recorrido = 0
    for jugador in jugadores:
        cuenta = cuenta + jugadorAtleta(jugador,dic)
        goles = goles + dic[pais][jugador]['Goles']
        recorrido = recorrido + dic[pais][jugador]['KM']
        goleskm = goles/recorrido
        if jugadorAtleta(jugador,dic)==1:
            jugadoresatletas.append([jugador,pais])
    porcentaje = cuenta/k
    nominado = paisBuenasPraticas(pais,dic)
    resultados.append([pais,porcentaje,goleskm,nominado])

# SALIDA
print('pais,porcentaje,goleskm,nominado')
print(resultados)
print('jugadores atletas')
print(jugadoresatletas)

# 3Eva_IIT2018_T1 texto aleatorio
# Tema 1
import random as rnd
# INGRESO
n = 10 # enunciado con 73
T = ['Hola','.','que','tal','-',',','amigo','amiga']

# PROCEDIMIENTO
texto = ''
k = len(T)
simbolo = ',.-'
antes = 0
cuenta = 0
while not(cuenta>=n):
    aleatorio = int(rnd.random()*k)+0
    untermino =  T[aleatorio]
    espalabra = not(untermino in simbolo)
    if cuenta == 0 and espalabra==1:
        texto = texto + untermino
        cuenta = cuenta + 1
        antes = espalabra
    if cuenta >0:
        if espalabra == 1:
            if antes == 1:
                texto = texto + ' '+ untermino
            if antes == 0:
                texto = texto + untermino
            antes = 1
            cuenta = cuenta+1
        if espalabra==0 and antes==1:
            if untermino==',':
                texto = texto + ', '
            if untermino=='.':
                texto = texto + '.\n'
            if untermino=='-':
                texto = texto +'-'
            antes = 0
            cuenta=cuenta+1
        # if espalabra==0 and antes ==0:
        #     print('no se pueden juntar simbolos')

# SALIDA
print('El texto generado es: ')
print(texto)
# Archivo
archivo = open('literatura.txt','w')
archivo.write(texto)
archivo.close()

Ejemplo:

El texto generado es: 
Hola Hola.
Hola amigo-amiga Hola que-
>>> 

Solución propuesta en Python, el primer bloque corresponde solo a las funciones requeridas en el examen. El segundo bloque corresponde a un programa de prueba.

# 3ra Evaluación I Término 2018
# Tema 2. Producción minera del país
import numpy as np

# Literal a
def extraerMinerales(discurso): 
    palabras = discurso.split(' ')
    cuales = []

    for unapalabra in palabras:
        # Tarea: verificar únicos
        if 'mral_' in unapalabra:
            mencionados = unapalabra[5:]
            mencionados = mencionados.title()
            cuales.append(mencionados)

    return(cuales)

# literal b
def calcularGanancias(P,C,T,precios):
    produccion = np.array(P)
    costosExtraccion = np.array(C, dtype=float)
    costosTransporte = np.array(T)
    
    # precio en forma de columna
    precios = np.transpose([precios])

    ventas = produccion*precios
    costo = costosTransporte + costosExtraccion
    ganancia = ventas - costo
    return(ganancia)

# literal c
def gananciaTotal(ganancia, minerales):
    ganametal = np.sum(ganancia,axis =1)
    
    ascendente = np.argsort(ganametal)
    descendente = np.argsort(-ganametal)

    totalmetal = ganametal[descendente]
    
    # convierte arreglo para ascendente
    minerales = np.array(minerales)
    cualmetal = minerales[descendente]

    ganatotal = (totalmetal,list(cualmetal))

    return(ganatotal)

# literal d
def top8(discurso,reporte):
    mencionados = extraerMinerales(discurso)
    totalmetal = reporte[0]
    cualmetal = reporte[1]
    
    interseccion = []
    m = len(cualmetal)
    for i in range(0,m,1):
        if (cualmetal[i] in mencionados):
            interseccion.append(cualmetal[i])
            
    mejoresmencionados = interseccion[:8]
    return (mejoresmencionados)

Programa de Prueba

Observación: las matrices C y T no tienen el mismo orden de magnitud a pesar de ser costos totales. Podría ser que el costo de extracción C sea por gramos, sin embargo las matrices se usan tal como fueron presentadas en el examen

# PROGRAMA DE PRUEBA -----
discurso = 'y el dia de ayer descubrimos en la mina mirador que la cantidad de mral_oro'

minerales = ['Oro', 'Plata', 'Cobre']
precios   = [38.48,    3.43,    0.01]

minas = ['MIRADOR', 'FRUTA_DEL_NORTE', 'LOMA_LARGA', 'otra']


P = [[ 13524000, 121072000,  1204000,  9632000],
     [ 28000000,    952000,  9632000, 96404000],
     [126980000,    896000, 92988000,  9604000]]

C = [[ 12.32, 10.23, 23.23, 19.23],
     [  3.13,  1.78,  2.45,  1.69],
     [  8.32,  5.25,  6.32,  6.89]]

T = [[ 43736616, 341786256,  5442080,  28241024],
     [ 76244000,   1827840, 13966400, 435746080],
     [156439360,   1121792,300723192,  10785292]]
            
# PROCEDIMIENTO
mencionados = extraerMinerales(discurso)

ganancias = calcularGanancias(P,C,T,precios)

ganatotal = gananciaTotal(ganancias, minerales)
totalmetal = ganatotal[0]
cualmetal = ganatotal[1]

mejoresmencionados = top8(discurso,ganatotal)


# SALIDA
print('a) los minerales mencionados son: ')
print(mencionados)

print('b) las ganancias totales son:')
print(ganancias)

print('c) ganancias totales por metal')
print(totalmetal)
print(cualmetal)

print('d) los 8 mejores mencionados: ')
print(mejoresmencionados)

los resultados en pantalla son :

a) los minerales mencionados son: 
['Oro']
b) las ganancias totales son:
[[  4.76666892e+08   4.31706429e+09   4.08878168e+07   3.42398317e+08]
 [  1.97959969e+07   1.43751822e+06   1.90713576e+07  -1.05080362e+08]
 [ -1.55169568e+08  -1.11283725e+06  -2.99793318e+08  -1.06892589e+07]]
c) ganancias totales por metal
[  5.17701732e+09  -6.47754890e+07  -4.66764983e+08]
['Oro', 'Plata', 'Cobre']
d) los 8 mejores mencionados: 
['Oro']
>>> 

Propuesta en Python, se incluye la función calcularFecha() se presenta para poder probar las funciones en el programa de prueba.

El archivo con datos de prueba usado es: rutasManejadas2018.txt

La propuesta considera el uso de listas, por ser parte de los ejercicios del proyecto para 3ra Evaluación.

# 3ra Evaluación I Término 2018
# Tema 1. Choferes y Rutas Trailers

# literal a
def cargarDatos(narchivo):
    loschoferes = []
    tabla = {}
    
    archivo = open(narchivo,'r')
    cabecera = archivo.readline()
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        ruta = partes[0]
        chofer = partes[1]
        fecha = partes[2]
        
        if not(chofer in loschoferes):
            loschoferes.append(chofer)

        if not(fecha in tabla):
            tabla[fecha]={ruta:[chofer]}
        else:
            if not(ruta in tabla[fecha]):
                tabla[fecha][ruta] = [chofer]
            else:
                tabla[fecha][ruta].append(chofer)
                
        linea = archivo.readline()
        
    archivo.close()

    return((loschoferes,tabla))

# función para pruebas, no requerida en la evaluación
import datetime as dtt
def calcularFecha(unafecha,n):
    formato = '%d-%m-%Y'
    fecha = dtt.datetime.strptime(unafecha,formato)
    pasada = fecha - dtt.timedelta(days=n)
    pasadatxt = dtt.datetime.strftime(pasada,formato)
    return(pasadatxt)

# literal b
def encontrarChoferes(tabla,loschoferes,unafecha,unaruta,n):
    simanejaron = []
    fechas = list(tabla.keys())
    for i in range(1,n+1,1):
        pasada = calcularFecha(unafecha,i)
        if (pasada in fechas):
            trabajaron = tabla[pasada][unaruta]
            for unchofer in trabajaron:
                if not(unchofer in simanejaron):
                    simanejaron.append(unchofer)
    nomanejaron = []
    for unchofer in loschoferes:
        if not(unchofer in simanejaron):
            nomanejaron.append(unchofer)
    return(nomanejaron)

# literal c
def grabarArchivo(tabla,loschoferes,unafecha,n):  
    narchivograba = unaruta+'_'+unafecha+'_'+str(n)+'.txt'
    
    archivo = open(narchivograba,'w')
    
    cabecera = 'Para la ruta '+unaruta+'\n'
    cabecera = cabecera + 'los choferes disponibles para la fecha '+unafecha+'\n'
    cabecera = cabecera + 'que no hayan manejado '+str(n)+' dias anteriores son: \n'
    archivo.write(cabecera)
    
    nomanejaron = encontrarChoferes(tabla,loschoferes,unafecha,unaruta,n)

    for cadachofer in nomanejaron:
        archivo.write(cadachofer+'\n')
    archivo.close()
    
    return(narchivograba)

programa de prueba, como trabajo extra, no requerido para el examen:

# PROGRAMA PRUEBA -------
# INGRESO
narchivo = 'rutasManejadas2018.txt'
unafecha = '19-05-2018'
unaruta = 'Guayaquil-Cuenca'
n = 2

# PROCEDIMIENTO
datos = cargarDatos(narchivo)
loschoferes = datos[0]
tabla = datos[1]
nomanejaron = encontrarChoferes(tabla,loschoferes,unafecha,unaruta,n)
elarchivo = grabarArchivo(tabla,loschoferes,unafecha,n)

# SALIDA
print('a) los choferes registrados son: ')
print(loschoferes)
print('   la tabla de trabajos es: ')
print(tabla)
print('b) los choferes que no manejaron en ')
print('  '+unaruta+', '+str(n)+' dias antes del '+unafecha+': ')
print(nomanejaron)
print('c) resultados en el archivo: ', elarchivo)

Se muestra el resultado en pantalla del programa usando los datos de prueba del archivo:

a) los choferes registrados son: 
['SMS', 'AGB', 'SMZ', 'EVN', 'AAQ']
   la tabla de trabajos es: 
{'17-05-2018': {'Guayaquil-Cuenca': ['SMS', 'SMZ'], 'Guayaquil-Daule': ['EVN']}, '18-05-2018': {'Guayaquil-Cuenca': ['AGB'], 'Guayaquil-Daule': ['AAQ']}}

b) los choferes que no manejaron en 
  Guayaquil-Cuenca, 2 dias antes del 19-05-2018: 
['EVN', 'AAQ']

c) resultados en el archivo:  Guayaquil-Cuenca_19-05-2018_2.txt
>>> 

Propuesta de solución en Python:

archivo de prueba: videojuegos.csv

# 3ra Evaluación II Término 2017
# Tema 2. biblioteca videojuegos

import numpy as np

def juegosConsolas(nomArchivo, categoria, decada):
    productos = []
    equipos = []
    listado = []
    if (decada>99):
        decada = decada%100
    archivo = open(nomArchivo,'r')
    # encabezado
    linea = archivo.readline()
    # primera linea de datos
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        njuego = partes[0]
        anio = int(partes[1])
        cons = partes[2]
        calf = float(partes[3])
        lista = partes[4].split(';')
        categ = lista[0]
        tags = lista[1:]
        if (anio>=decada and anio<=(decada+10) and (categ==categoria)):
            if not(njuego in productos):
                productos.append(njuego)
            if not(cons in equipos):
                equipos.append(cons)
            listado.append([njuego,cons,calf])
        linea = archivo.readline()
    archivo.close()
    respuesta = (productos,equipos, listado)
    return(respuesta)

def crearMatriz(nomArchivo, categoria, decada):
    indices = juegosConsolas(nomArchivo, categoria, decada)
    filas = indices[0]
    columnas = indices[1]
    datos = indices[2]
    n = len(filas)
    m = len(columnas)
    matriz = np.zeros(shape=(n,m), dtype=float)
    q = len(datos)
    for i in range(0,q,1):
        f = filas.index(datos[i][0])
        c = columnas.index(datos[i][1])
        valor = datos[i][2]
        matriz[f,c] = valor
    return(matriz)

def mejoresJuegos(nomArchivo, categoria, decada):
    indices = juegosConsolas(nomArchivo, categoria, decada)
    matriz = crearMatriz(nomArchivo, categoria, decada)
    subtotal = np.sum(matriz, axis=0)
    conteo = np.count_nonzero(matriz,axis=0)
    prom = subtotal/conteo
    indicesMax = prom.argsort()[-5::]
    n = len(indicesMax)
    narchivo = 'Mejores.txt'
    archivo = open(narchivo,'w')
    for i in range(0,n,1):
        cual = indicesMax[i]
        linea = indices[1][cual] + ',' + str(prom[cual]) + '\n'
        archivo.write(linea)
    archivo.close()
    respuesta = 'archivo creado'
    return(respuesta)

def colecciones(nomArchivo, palabras):
    respuesta = []
    archivo = open(nomArchivo,'r')
    # encabezado
    linea = archivo.readline()
    # primera linea de datos
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        lista = partes[4].split(';')
        categ = lista[0]
        tags = lista[1:]
        if (palabras == tags):
            if not(njuego  in respusta):
                respuesta.append(njuego)
    return(respuesta)

# INGRESO
nomArchivo = 'videojuegos.csv'
categoria = 'RPG'
decada = 80

# PROCEDIMIENTO
respuesta1 = juegosConsolas(nomArchivo, categoria, decada)
respuesta2 = crearMatriz(nomArchivo, categoria, decada)
respuesta3 = mejoresJuegos(nomArchivo, categoria, decada)

# SALIDA
print('juegos y consolas de: ', decada, categoria)
print(respuesta1[0])
print(respuesta1[1])
print('matriz: ')
print(respuesta2)
print('seleccionados: ')
print(respuesta3)

Propuesta de solución en Python:

# 3ra Evaluación II Término 2017
# Tema 1. Mantenimiento de vehículos
# Tarea: Analizar el número de días

def mantenimientos(strPlaca, dictHistorial, dictMantenimiento):
    resultado = []
    # Estado del vehículo analizado
    estado = dictHistorial[strPlaca]['registro']
    n = len(estado)
    # grupos por tipo mantenimiento
    preven = []
    repara = []
    nada = []
    prev = dictMantenimiento['preventivo']
    corr = dictMantenimiento['correctivo']
    m = len(prev)
    q = len(corr)
    # Analiza cada parte del vehículo    
    for i in range(0,n,1):
        parte = estado[i][0]
        dias = estado[i][1]
        usoKm = estado[i][2]
        # Analiza correctivos
        for j in range(0,q,1):
            c_parte = corr[j][0]
            c_dias  = corr[j][1]
            c_usoKm = corr[j][2]
            if (parte == c_parte):
                if (usoKm >= c_usoKm):
                    repara.append(parte)
        # Analiza preventivos
        for k in range(0,m,1):
            p_parte = prev[k][0]
            p_dias  = prev[k][1]
            p_usoKm = prev[k][2]
            if (parte == p_parte):
                if (usoKm >= p_usoKm and not(parte in repara)):
                    preven.append(parte)
        # Revisa si lo añade a "nada"
        if not(parte in repara) and not(parte in preven):
            nada.append(parte)

    # Convierte a tuplas como se requiere
    m = len(preven)
    q = len(repara)
    p = len(nada)
    for k in range(0,m,1):
        resultado.append((preven[k],'preventivo'))
    for j in range(0,q,1):
        resultado.append((repara[j],'correctivo'))
    for j in range(0,p,1):
        resultado.append((nada[j],'nada'))
    return(resultado)

def semaforo(strPlaca, dictHistorial, dictMantenimiento):
    resultado = {'amarillo':[],'rojo':[],'verde':[]}
    diagnostico = mantenimientos(strPlaca, dictHistorial, dictMantenimiento)
    n = len(diagnostico)
    for i in range(0,n,1):
        if (diagnostico[i][1]== 'preventivo'):
            resultado['amarillo'].append(diagnostico[i][0])
        if (diagnostico[i][1]== 'correctivo'):
            resultado['rojo'].append(diagnostico[i][0])
        if (diagnostico[i][1]== 'nada'):
            resultado['verde'].append(diagnostico[i][0])
    return(resultado)

def recomendar(strparte, strtipoMantenimiento, dictHistorial, dictMantenimiento):
    darservicio = []
    for cliente in dictHistorial:
        colores = semaforo(cliente, dictHistorial, dictMantenimiento)
        if (strtipoMantenimiento=='preventivo'):
            partes = colores['amarillo']
            if (strparte in partes):
                darservicio.append(cliente)
        if (strtipoMantenimiento=='correctivo'):
            partes = colores['rojo']
            if (strparte in partes):
                darservicio.append(cliente)
    return(darservicio)

# INGRESO
dictMantenimiento = {
    'preventivo': [('llantas',  60,  4500),
                   ('bujias',   45,  3000)],
    'correctivo': [('llantas',  90,  6000),
                   ('zapatas', 120, 10000)]
    }

dictHistorial = {
    'GEC-2411': {
        'propietario': 'Eduardo Cueva',
        'registro': [('llantas',  12, 32500),
                     ('zapatas', 180, 500)]
        },
    'GAA-0321': {
        'propietario': 'Andrea Martinez',
        'registro': [('bujias',   40, 500),
                     ('zapatas', 120, 100)]
        }
    }
strPlaca = 'GEC-2411'
strparte = 'llantas'
strtipoMantenimiento = 'correctivo'

# PROCESAMIENTO
diagnostico = mantenimientos(strPlaca, dictHistorial, dictMantenimiento)
colores = semaforo(strPlaca, dictHistorial, dictMantenimiento)
darservicio = recomendar(strparte, strtipoMantenimiento, dictHistorial, dictMantenimiento)

# SALIDA
print('El diagnóstico de la placa : ', strPlaca)
print(diagnostico)
print('El equivalente en semaforo : ', strPlaca)
print(colores)
print('clientes por dar servicio '+ strtipoMantenimiento + ' de ' + strparte)
print(darservicio)

Propuesta de solución en Python:

se requiere los archivos y su contenido: costos.txt

10
0.2
0.5
0.3

mensaje01.txt

El cuerpo humano es el carruaje;
el yo, el hombre que lo conduce;
el pensamiento son las riendas,
y los sentimientos, los caballos.

algoritmo:

# 3ra Evaluación I Término 2016
# Tema 1. costo de mensaje
# Tarea: revisar si es necesario el uso de mayúsculas/minúsculas

# literal a)
def cargarDatos(nombreArchivo):
    
    archivo = open(nombreArchivo, 'r')
    unalinea = archivo.readline()
    
    unalinea = unalinea.strip('\n')
    m = int(unalinea)
    unalinea = archivo.readline()
    unalinea = unalinea.strip('\n')
    corta = float(unalinea)
    unalinea = archivo.readline()
    unalinea = unalinea.strip('\n')
    larga = float(unalinea)
    unalinea = archivo.readline()
    unalinea = unalinea.strip('\n')
    infinitivo = float(unalinea) 

    archivo.close()

    tarifas = {'m':m,
               'corta':corta,
               'larga':larga,
               'infinitivo':infinitivo}
    return(tarifas)


def cargarDatos2(nombreArchivo):
    lista = []
    
    archivo = open(nombreArchivo, 'r')
    unalinea = archivo.readline()
    while not(unalinea==''):
        unalinea = unalinea.strip('\n')
        lista.append(unalinea)
        unalinea = archivo.readline()
    archivo.close()

    tarifas = {'m':int(lista[0]),
               'corta':float(lista[1]),
               'larga':float(lista[2]),
               'infinitivo':float(lista[3])}
    return(tarifas)

def calcularCostos(tarifas, nombreArchivo):
    costo = 0
    # Carga en una lista
    lista=[]
    archivo = open(nombreArchivo, 'r')
    unalinea = archivo.readline()
    while not(unalinea==''):
        unalinea = unalinea.strip('\n')
        lista.append(unalinea)
        unalinea = archivo.readline()
    archivo.close()
    #Procesar las lineas
    n = len(lista)
    i = 0
    while not(i>=n):
        linea = lista[i]
        palabras = linea.split(' ')
        m =len(palabras)
        j=0
        while not(j>=m):
            palabras[j] = palabras[j].strip(',')
            palabras[j] = palabras[j].strip(';')
            palabras[j] = palabras[j].strip('.')
            tamano = len(palabras[j])
            valor = 0
            if (tamano  tarifas['m']):
                valor = tarifas['larga']
            k =  len(palabras[j])
            ultimas = palabras[j][k-2]+palabras[j][k-1]
            if (ultimas == 'ar' or ultimas=='er' or ultimas=='ir'):
                valor = tarifas['infinitivo']
            costo = costo + valor
            j=j+1
        i=i+1
    return(costo)

# PROGRAMA DE PRUEBA
tarifas = cargarDatos('costos.txt')
costo = calcularCostos(tarifas, 'mensaje01.txt')
print(costo)

Propuesta de solución en Python:

Para la prueba del algoritmo, se requiere los archivos:

notas-2015-I.csv

notas-2013-II.csv

# 3ra Evaluación I termino 2017
# Tema 1. 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)

Propuesta de solución en Python:

# 3ra Evaluación I termino 2017
# Tema 2. Registro de Huracanes 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)

Propuesta de solución en Python, El ejercicio tiene tarea por completar.

Para las pruebas, requiere el archivo clientes01.csv en el mismo directorio del archivo.py

# 3ra Evaluación II Término 2016-2017
# Tema 1. Facturar llamadas telefónicas
# se incluye la estructura de diccionarios.
# Tarea: Completar facturación y estadísticas

def obtenerClientes(nombreArchivo):
    facturar={}

    archivo=open(nombreArchivo,'r')
    linea = archivo.readline()
    while not(linea==''):
        linea=linea.strip('\n')
        partes=linea.split(',')
        ced = partes[0]
        num = partes[1]
        sec = partes[2]
        parm = partes[3].split('|')
        nac = float(parm[0])
        ext = float(parm[1])
        est = partes[4]

        if not(ced in facturar):
            facturar[ced] = {num:{
                             'sector': sec,
                             'nacional': nac,
                             'internac': ext,
                             'estado': est }}
        else: 
            facturar[ced][num] = {
                             'sector': sec,
                             'nacional': nac,
                             'internac': ext,
                             'estado': est }
        
        linea = archivo.readline()
    archivo.close()
    
    return(facturar)

def generarFactura(tabla):
    # Lista de clientes
    cedulas = tabla.keys()
    cedulas = list(cedulas)
    n = len(cedulas)

    # Mostrar cada cliente
    i = 0
    while not(i>=n):
        # Para pantalla
        # print(cedulas[i])
        # Cada archivo
        narchivo = cedulas[i] + '.txt'
        archivo = open(narchivo, 'w')
        archivo.write('Empresa Telefonica de Guayaquil \n')
        archivo.write('cliente: ' + cedulas[i] + '\n')
        archivo.write('Detalle Deuda: \n')

        tablanumeros = tabla[cedulas[i]]
        # print(tablanumeros)
        numeros = tablanumeros.keys()
        numeros = list(numeros)
        # print(numeros)
        m = len(numeros)
        j=0
        while not(j>=m):
            datos = tablanumeros[numeros[j]]
            nac = tablanumeros[numeros[j]]['nacional']
            costonac = nac * 0.03
            archivo.write(numeros[j] + ' nac: '+str(costonac)+ '\n')
            j=j+1
        
        archivo.close()
        
        i=i+1
    return()

# PROGRAMA
# INGRESO
narchivo = 'clientes.csv'

# PROCEDIMIENTO
tabla = obtenerClientes(narchivo)

# SALIDA
generarFactura(tabla)

# -------
# Usado para explicación de uso de diccionarios
### Lista de clientes
##cedulas = tabla.keys()
##cedulas = list(cedulas)
##n = len(cedulas)
##
### Salida
##print('los clientes son: ', cedulas)
##print('los datos del cliente son:')
##for i in range(0,n,1):
##    print(cedulas[i])
##    numeroscedula = tabla[cedulas[i]].keys()
##    print(numeroscedula)