# 3ra Eva III Term 2003
# Tema 4. Informe notas estudiantes
# INGRESO
estudiantes = []
n = int(input('cupo: '))
i = 0
while not(i>=n):
nom = input('nombre: ')
eda = int(input('edad: '))
gen = input(' genero m/f: ')
while not(gen=='f' or gen=='m'):
print(' genero f o m ')
gen = input('genero: ')
par = int(input('parcial: '))
while not(par>=0 and par<=100):
print(' nota son [0,100] ')
par = int(input('parcial: '))
fin = int(input('final: '))
while not(fin>=0 and fin<=100):
print(' nota son [0,100] ')
fin = int(input('final: '))
registro = {'nombre':nom,
'edad':eda,
'genero':gen,
'parcial':par,
'final':fin}
estudiantes.append(registro)
i = i+1
# ingresa sin extension '.txt'
narchivo = input('nombre del archivo: ')
narchivo = narchivo + '.txt'
# PROCEDIMIENTO
# Guarda el archivo con datos estudiantes
n = len(estudiantes)
archivo = open(narchivo, 'w')
i = 0
while not(i>=n):
nom = estudiantes[i]['nombre']
eda = estudiantes[i]['edad']
gen = estudiantes[i]['genero']
par = estudiantes[i]['parcial']
fin = estudiantes[i]['final']
linea = nom +','+str(eda)+','+gen
linea = linea + ',' + str(par)
linea = linea + ',' + str(fin) + '\n'
archivo.write(linea)
i = i+1
archivo.close()
# SALIDA
print(estudiantes)
s3Eva_IIT2018_T2 Jugadores Sudamericano Sub-20
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)
s3Eva_IIT2018_T1 texto aleatorio
# 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- >>>
s3Eva_IT2018_T2 Producción minera del país
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'] >>>
s3Eva_IT2018_T1 Choferes y Rutas Trailers
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
>>>
s3Eva_IIT2017_T2 biblioteca videojuegos
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)
s3Eva_IIT2017_T1 Mantenimiento vehículos
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)
s3Eva_IT2016_T1 Costo de mensaje
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)
s3Eva_IT2017_T1 Archivos de notas por semestre
Propuesta de solución en Python:
Para la prueba del algoritmo, se requiere los archivos:
# 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)
s3Eva_IT2017_T2 Huracanes en Atlantico Norte
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)