s3Eva_IIT2010_T1 Matriz con aleatorios no repetidos (desordena)

Ejercicio: 3Eva_IIT2010_T1 Matriz con aleatorios no repetidos (desordena)

Propuesta de solución en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IIT2010_T1 Matriz con aleatorios no repetidos (desordena)
# Propuesta: edelros@espol.edu.ec
# Tarea: integrar con tema 3

import numpy as np
import random as rnd

def desordena(n): 
    matriz = -1*np.ones(shape=(n,n), dtype=int)
    usados = []
    
    # entero aleatorio [0,n**2), no incluye n**2
    intervalo = n**2
    
    fila = 0
    while not(fila>=n):
        
        columna = 0
        while not(columna>=n):

            # numero no repetido
            numero = int(rnd.random()*intervalo)+0
            while numero in usados:
                numero = int(rnd.random()*intervalo)+0
            
            matriz[fila,columna] = numero
            usados.append(numero)
            
            columna = columna + 1
            
        fila = fila + 1
    return(matriz)

resultado del algoritmo:

>>> desordena(3)
array([[0, 7, 2],
       [6, 5, 8],
       [4, 1, 3]])
>>> desordena(3)
array([[7, 3, 6],
       [8, 1, 0],
       [5, 2, 4]])
>>> 

s3Eva_IIIT2003_T4 Informes notas de estudiantes

Ejercicio: 3Eva_IIIT2003_T4 Informes notas de estudiantes

Propuesta de solución en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IIIT2003_T4 Informes notas de 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)

resultado del algoritmo

upo: 5
nombre: Juan
edad: 19
 genero m/f: m
parcial: 65
final: 40
nombre: Maria
edad: 18
 genero m/f: f
parcial: 70
final: 80
nombre: Ana
edad: 19
 genero m/f: f
parcial: 90
final: 92
nombre: Juan
edad: 20
 genero m/f: m
parcial: 40
final: 80
nombre: Rosa
edad: 18
 genero m/f: f
parcial: 80
final: 85
nombre del archivo: calificaciones
[{'nombre': 'Juan', 'edad': 19, 'genero': 'm',
  'parcial': 65, 'final': 40},
 {'nombre': 'Maria', 'edad': 18, 'genero': 'f',
  'parcial': 70, 'final': 80},
 {'nombre': 'Ana', 'edad': 19, 'genero': 'f',
  'parcial': 90, 'final': 92},
 {'nombre': 'Juan', 'edad': 20, 'genero': 'm',
  'parcial': 40, 'final': 80},
 {'nombre': 'Rosa', 'edad': 18, 'genero': 'f',
  'parcial': 80, 'final': 85}]
>>> 

s3Eva_IIT2018_T2 Jugadores Sudamericano Sub-20

Ejercicio: 3Eva_IIT2018_T2 Jugadores Sudamericano Sub-20

Propuesta de solución en Python, se usa un archivo de prueba: br-ur.csv

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IIT2018_T2 Jugadores Sudamericano Sub-20

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

Ejercicio: 3Eva_IIT2018_T1 texto aleatorio

Propuesta de solución en Python:
<Ejemplo:

El texto generado es: 
Hola Hola.
Hola amigo-amiga Hola que-
>>> 
# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IIT2018_T1 texto aleatorio

import random as rnd

# INGRESO
n = 10 # enunciado con 73
T = ['Hola','.','que','tal','-',',','amigo','amiga']

# PROCEDIMIENTO
k = len(T)
texto   = ''
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()

s3Eva_IT2018_T2 Producción minera del país

Ejercicio: 3Eva_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.

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IT2018_T2 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

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL

# 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

Ejercicio: 3Eva_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.

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IT2018_T1 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:

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 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

Ejercicio: 3Eva_IIT2017_T2 biblioteca videojuegos

Propuesta de solución en Python:

archivo de prueba: videojuegos.csv

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IIT2017_T2 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)

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

Ejercicio: 3Eva_IIT2017_T1 Mantenimiento vehículos

Propuesta de solución en Python:

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IIT2017_T1 Mantenimiento 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

Ejercicio: 3Eva_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:

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IT2016_T1 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

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)