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)

2Eva_IIT2017_T1 Citas San Valentin

2da Evaluación II Término 2017-2018. Febrero 14, 2018 /CCPG001

(Editado para tarea, se mantiene el objetivo de aprendizaje)

Tema 1. (35 puntos) Para un servicios de citas «san valentín» , se pretende presentar parejas para el día del «amor y la amistad». Los datos de las personas se almacenan en una estructura de datos tipo diccionario: dicPersonas.

Para conocer la compatibilidad entre dos personas, se utilizan sus características y el índice de Tanimoto  que es un valor entre [0, 1] determinado como:

Tanimoto(P_1,P_2) = \frac{|caracteristicasP_1 \cap caracteristicasP_2|}{|caracteristicasP_1 \cup caracteristicasP_2|}

El emparejamiento resulta verdadero cuando: el valor del índice de Tanimoto es superior o igual al nivel de aceptación y la pareja no han tenido citas previas (sin importar su tipo: exitosa o fallida).

dicPersonas = {
    'p1021': {'nombre': 'Carlos S.',
              'caracteristicas': {'alegre',
                                  'fumador',
                                  'hacker',
                                  'deportista'},
              'citas': {'fallidas': ['P1902',
                                     'P2893',
                                     'P2310'],
                        'exitosas': ['P4025',
                                     'P1001']}
              },
    'p1001': {'nombre': 'Andrea V.',
              'caracteristicas': {'farrero',
                                  'programador',
                                  'fabuloso',
                                  'deportista'},
              'citas': {'fallidas': ['P1802'],
                        'exitosas': ['P1021',
                                     'P1002']}
              }
    }

a) Realice una función hayEmparejamiento(codigoP1, codigoP2, dicpersonas, aceptacion) para encontrar los valores del índice de Tanimoto y emparejamiento.

La función recibe el código de dos personas, el diccionario de personas (dicpersonas) y el nivel de aceptación mínimo [0,1]  para entregar los resultados en una tupla.

b) Desarrolle la función imprimirResultados(codigoPersona, dicPersonas, aceptacionMinimo, aceptacionMaximo) que genera un un archivo codigoPersona.txt, con el reporte de compatibilidad de la codigoPersona con las de género opuesto en el diccionario.

Cada línea del archivo tiene el formato siguiente:

codigo$Nombre$Caracteristica1,caracteristica2, ... $indiceTanimoto$textoCompatibilidad\n

Donde textoCompatibilidad es ‘aceptar‘ si el índice de Tanimoto está entre los niveles de aceptación mínimo y máximo, sino tiene la palabra ‘rechazar‘.

c) Elabore la  función compatibles(codigoPersona, dicPersonas, aceptacion) que a partir de un codigoPersona y considerando el nivel de aceptación, genera un reporte de emparejamiento en la forma del diccionario «respuesta» .

El diccionario «respuesta» contiene el nombre, caraterísticas, índice de Tanamoto y cantidad de citas fallidas.
El parámetro de aceptación tiene valor por defecto de 0.43,

Ejemplo:
respuesta = {
    'p1001': {'nombre': 'Andrea V.',
              'caracteristicas': {'deportista',
                                  'programador',
                                  'fabuloso',
                                  'farrero'},
              'indice': 0.14,
              'fallidas': 1
              }
    }

Rúbrica: literal a (10 puntos), literal b (13 puntos), literal c (12 puntos)

Referencia: Archivo original 2Eva_IIT2017.pdf

2Eva_IIT2017_T3 Prueba de escritorio, arreglos

2da Evaluación II Término 2017-2018. Febrero 14, 2018 /CCPG001

Tema 3. (10 puntos) Para las preguntas, considere matriz M como un arreglo (Numpy) :

import numpy as np

M =  np.array([['h','o','l','a'],
               ['m','u','n','d'],
               ['o','E','S','P'],
               ['O','L',':',')']])

a) Indique la salida por pantalla de las siguientes instrucciones. Justifique su respuesta:

f,c = M.shape
t = ''
for j in range(c):
    t = t + ''.join(M[:,j].tolist())
    
print(t)

b) Indique la salida por pantalla de las siguientes instrucciones. Justifique su respuesta:

print((((M =='o')|(M=='O')).sum(axis=0)>0).sum())

Rúbrica: cada literal 5 puntos

Referencia: Archivo original 2Eva_IIT2017.pdf

2Eva_IIT2017_T2 Reporte comercio internacional

2da Evaluación II Término 2017-2018. Febrero 14, 2018 /CCPG001

(Editado para tarea, se mantiene el objetivo de aprendizaje)

Tema 2. (55 puntos) Para el intercambio comercial entre paises se registran las  transacciones de compra/venta de productos por categoría.

Las categorías agrupan productos como: flores, frutas, maderas, etc.

La categoría ‘flores’ contiene: claveles, rosas, tulipanes, girasoles, etc. mientras que frutas tiene a cacao, banano, etc.

Las transacciones para cada catetoría se almacenan en archivos diferentes.

Ejemplo de archivo: Flores.txt, Maderas.txt

Comprador, Vendedor, Producto, UnidadesVendidas, Ventasen$, Fecha
Estados Unidos,Ecuador,rosas,59284,631432.21,2018-01-10
Holanda,Japon,tulipanes,2384,12424.87,2017-11-22
...
Estados Unidos,Ecuador,girasoles,38284,331432.75,2018-02-01

Note que un país puede vender el mismo producto al mismo comprador pero en una fecha diferente.

a) Elabore una función calculaTotales(categoria) que procesa los datos del archivo ‘categoria.txt’ y determina los totales de las transacciones entre países. Los totales se muestran en un diccionario de la forma:

totales ={(comprador,vendedor,producto): totalUnidades}

Por ejemplo, si en la categoríaFlores’, ‘Estados Unidos’ le compró ‘rosas’ a ‘Ecuador’ en 12 fechas diferentes, el total deberá ser la suma de los valores de las 12 transacciones:

{('Estados Unidos', 'Ecuador', 'rosas'): 257868}

b) Escriba una función consolidado(nomArchivo, categorias) que dada una lista de categorías genera el listado del acumulado de unidades vendidas por comprador, vendedor y producto.

El resultado se almacena en el archivo ‘nomArchivo.txt’ con la siguiente estructura:

Comprador,Vendedor,Categoría,Producto,TotalUnidadesVendidas

Para el resto del ejercicio, asuma que dispone de una función crearMatriz(narchivo) que recibe el nombre del archivo consolidado y devuelve una tupla con tres elementos:
(1) Matriz M cuyas filas representan países vendedores, columas representan productos ordenados alfabeticamente dentro de cada categoría y las celdas representan ventas totales en unidades.
(2) lista con las etiquetas de las filas y
(3) lista con las etiquetas de las columnas.

c) La función ventasCategorias(nomArchivo, dicCat) realiza un reporte por categoría de los 5 países que han vendido menos productos.

Cada reporte se almacena en un archivo ‘total_categoria.txt’.
Los datos provienen del archivo consolidado nomArchivo.txt y un diccionario donde las claves son las categorías y los valores son listas con todos los productos.
Los productos se encuentran ordenados alfabeticamente dentro de cada categoría, las categorías no están ordenadas alfabéticamente.

Cada archivo tendrá la siguiente estructura:

País,Total_Ventas

Rúbrica: literal a (15 puntos), literal b (15 puntos), literal c (25 puntos).


Referencia: Archivo original 2Eva_IIT2017.pdf

archivos usados: Flores.txtMaderas.txt
para obtener respuestas: categoriasconsolidado.txt, totalFlores, totalMaderas

s2Eva_IIT2017_T1 Citas San Valentin

Ejercicio: 2Eva_IIT2017_T1 Citas San Valentin

Propuesta de solución en Python:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2da Evaluación II Término 2017
# Tema 1. Citas San Valentin

def hayEmparejamiento(codigoP1, codigoP2, dicPersonas, aceptacion):
    tanimoto = 0
    aceptado = False
    gen1 = dicPersonas[codigoP1]['genero']
    gen2 = dicPersonas[codigoP2]['genero']
    caract1 = dicPersonas[codigoP1]['caracteristicas']
    caract2 = dicPersonas[codigoP2]['caracteristicas']
    tanimoto = len(caract1&caract2)/len(caract1|caract2)
    citaf = dicPersonas[codigoP1]['citas']['fallidas']
    citae = dicPersonas[codigoP1]['citas']['exitosas']

    if (gen1!=gen2 and
        tanimoto>=aceptacion and 
        not(codigoP2 in citaf) and
        not(codigoP2 in citae)):
        
        aceptado = True
        
    respuesta = (tanimoto,aceptado)
    return(respuesta)

def imprimirResultados(codigoPersona, dicPersonas,
                       aceptacionMinimo, aceptacionMaximo):
    narchivo = codigoPersona + '.txt'
    archivo  = open(narchivo,'w')
    quienes  = dicPersonas.keys()
    gen1 = dicPersonas[codigoPersona]['genero']
    for otra in quienes:
        gen2 = dicPersonas[otra]['genero']
        
        if (gen1 != gen2 and
            otra != codigoPersona):
            
            nombre = dicPersonas[otra]['nombre']
            linea = otra + '$' + nombre
            caract = dicPersonas[otra]['caracteristicas']
            cadena = ''
            
            for unacaract in caract:
                cadena = cadena + unacaract + ','
                
            cadena = cadena.strip(',')
            linea = linea + '$' + cadena
            tupla = hayEmparejamiento(codigoPersona,
                                      otra,dicPersonas,
                                      aceptacionMinimo)
            tanimoto = tupla[0]
            aceptado = tupla[1]
            linea = linea + '$' + str(tanimoto)
            responde = 'aceptar'
            if aceptado != False:
                responde = 'rechazar'
            linea = linea + '$' + responde + '\n'
            archivo.write(linea)
    archivo.close()
    respuesta = 'Archivos creados'
    return(respuesta)

def compatibles(codigoPersona, dicPersonas, aceptacion=0.43):
    respuesta={}
    quienes = dicPersonas.keys()
    gen1 = dicPersonas[codigoPersona]['genero']
    for otra in quienes:
        gen2 = dicPersonas[otra]['genero']
        if (gen1!= gen2 and otra != codigoPersona):
            tupla = hayEmparejamiento(codigoPersona, otra,
                                      dicPersonas, aceptacion)
            tanimoto=tupla[0]
            if tanimoto>=aceptacion:
                nombre2 = dicPersonas[otra]['nombre']
                caract2 = dicPersonas[codigoP2]['caracteristicas']
                citasf2 = len(dicPersonas[codigoP2]['citas']['fallidas'])
                respuesta[otra] = {'nombre':nombre2,
                                   'caracteristicas':caract2,
                                   'indice': tanimoto,
                                   'fallidas': citasf2
                                   }
    return(respuesta)

# PROGRAMA PRUEBA
# INGRESO datos de prueba
dicPersonas = {
    'p1021': {'nombre': 'Carlos S.',
              'genero': 'm',
              'caracteristicas': {'alegre',
                                  'fumador',
                                  'hacker',
                                  'deportista'},
              'citas': {'fallidas': ['P1902',
                                     'P2893',
                                     'P2310'],
                        'exitosas': ['P4025',
                                     'P1001']}
              },
    'p1001': {'nombre': 'Andrea V.',
              'genero': 'f',
              'caracteristicas': {'farrero',
                                  'programador',
                                  'fabuloso',
                                  'deportista'},
              'citas': {'fallidas': ['P1802'],
                        'exitosas': ['P1021',
                                     'P1002']}
              }
    }

codigoP1 = 'p1021'
codigoP2 = 'p1001'
aceptacionMin = 0.1
aceptacionMax = 0.8

# PROCEDIMIENTO
pareja = hayEmparejamiento(codigoP1,codigoP2,
                           dicPersonas,
                           aceptacionMin)
resultado = imprimirResultados(codigoP1,
                               dicPersonas,
                               aceptacionMin,
                               aceptacionMax)
posibles = compatibles(codigoP1, dicPersonas,
                       aceptacionMin)

# Salida
print('emparejamiento de: ', codigoP1),
print(pareja)
print(resultado)
print('las parejas posibles: ')
print(posibles)

s2Eva_IIT2017_T2 reporte comercio internacional

Ejercicio: 2Eva_IIT2017_T2 Reporte comercio internacional

Propuesta de solución en Python:

archivos usados: Flores.txtMaderas.txt
para obtener respuestas: categoriasconsolidado.txt, totalFlores, totalMaderas

totales de:  Flores
{('Estados Unidos', 'Ecuador', 'rosas'): 118568,
 ('Holanda', 'Japon', 'tulipanes'): 2384,
 ('Estados Unidos', 'Ecuador', 'girasoles'): 38284}
*** Consolidando productos:  Archivos consolidados guardados
resultados de funcion crearMatriz(): 
(array([[ 38284, 118568,      0,  69284,  69284,  48284],
       [     0,      0,   2384,      0,   3384,      0]]),
       ['Ecuador', 'Japon'],
       ['girasoles', 'rosas', 'tulipanes', 'abeto', 'cereso', 'teca'],
       {'Flores': ['girasoles', 'rosas', 'tulipanes'], 
'Maderas': ['abeto', 'cereso', 'teca']})
*** Ventas por categoria son:  Archivos venta por categoria guardados
>>> 

Instrucciones en Python:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2017_T2 reporte comercio internacional
import numpy as np

def calculaTotales(categoria):
    totales = {}

    narchivo = categoria + '.txt'
    archivo  = open(narchivo,'r')

    # Linea de encabezado
    linea = archivo.readline()
    # Primera linea de datos
    linea = archivo.readline() 
    while not(linea ==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        indice = (partes[0],partes[1],partes[2])
        cantidad = int(partes[3])
        valor = float(partes[4])

        if indice in totales:
            totales[indice] = totales[indice] + cantidad
        else:
            totales[indice] = cantidad
        linea = archivo.readline()
    archivo.close()

    return(totales)

def consolidado(nomArchivo,categorias):
    archivo = open(nomArchivo, 'w')
    for unacat in categorias:
        total = calculaTotales(unacat)

        # totales.update(total)
        for indice in total:
            comp = indice[0] 
            vend = indice[1]
            cate = unacat
            prod = indice[2]
            cant = total[indice]
            linea = comp + ',' + vend + ','
            linea = linea + cate + ',' + prod
            linea = linea + ',' + str(cant) + '\n'
            archivo.write(linea)
            
    archivo.close()

    respuesta = 'Archivos consolidados guardados'
    return(respuesta)

def ventasCategorias(nomArchivo, dicCat):
    # Por simplicidad, supone que el orden
    # en dicCat es el mismo que en
    # lista productos
    # Tarea: seleccionar los 5 vendedores mas bajos

    paisproducto = crearMatriz(nomArchivo)
    matriz     = paisproducto[0]
    vendedores = paisproducto[1]
    productos  = paisproducto[2]
    categorias = dicCat.keys()

    a = 0
    for categ in categorias:
        incluye = dicCat[categ]
        k = len(incluye)
        b = a + k
        seccion = matriz[:,a:b]
        suma = np.sum(seccion, axis=1)
        a = a + k
        
        unifica = []
        for f in range(0,len(vendedores),1):
            unifica.append([vendedores[f],suma[f]])

        narchivo = 'total'+categ+'.txt'
        archivo = open(narchivo,'w')
        for f in range(0,len(unifica),1):
            linea = unifica[f][0]+','+str(unifica[f][1])+'\n'
            archivo.write(linea)
        archivo.close()

    respuesta = 'Archivos venta por categoria guardados'
    return(respuesta)

# El examen supone que esta función ya existe.
# adicionalmete crea dicCat para hacer funcional el problema
def crearMatriz(nomArchivo):
    # Obtiene los indices para la matriz
    vendedores = []
    categoria = {}
    lista = []

    archivo = open(nomArchivo,'r')
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes =  linea.split(',')
        unvendedor = partes[1]
        unacategoria = partes[2]
        unproducto = partes[3]
        cant = int(partes[4])

        if not(unvendedor in vendedores):
            vendedores.append(unvendedor)
        if not(unacategoria in categoria):
            categoria[unacategoria] = [unproducto]
        else:
            if not(unproducto in categoria[unacategoria]):
                categoria[unacategoria].append(unproducto)
        lista.append([unvendedor,unproducto,cant])
        linea = archivo.readline()
    archivo.close()

    # Ordena los productos alfabeticamente
    productos = []
    for unacategoria in categoria:
        prod = categoria[unacategoria]
        prod.sort()
        categoria[unacategoria] = prod
        productos = productos + prod

    # Crea la matriz
    n = len(vendedores)
    m = len(productos)
    matriz = np.zeros(shape=(n,m),dtype=int)
    k = len(lista)
    for i in range(0,k,1):
        fila = vendedores.index(lista[i][0])
        columna = productos.index(lista[i][1])
        matriz[fila,columna] = matriz[fila,columna] + lista[i][2]
    respuesta = (matriz, vendedores, productos,categoria)
    return(respuesta)

# PROGRAMA
# INGRESO datos prueba
categoria = 'Flores'
categorias = ['Flores','Maderas']
nomArchivo = 'categoriasconsolidado.txt'

# PROCEDIMIENTO
totales = calculaTotales(categoria)
consolidaprod = consolidado(nomArchivo, categorias)
paisproducto = crearMatriz(nomArchivo)
dicCat = paisproducto[3]
ventacat = ventasCategorias(nomArchivo, dicCat)

# SALIDA
print('totales de: ', categoria)
print(totales)
print('*** Consolidando productos: ', consolidaprod)
print('resultados de funcion crearMatriz(): ')
print(paisproducto)
print('*** Ventas por categoria son: ', ventacat)

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)

1Eva_IIT2017_T4 Prueba de escritorio, listas

1ra Evaluación II Término 2017-2018, Diciembre 1, 2017. CCPG001

Tema 4. (10 puntos)
1. Indique la salida por pantalla del siguiente código. Justifique su respuesta.

f = ['a', 'c', 'z', 'm', 'k']
g = [3,4,5,6,5,7]
t = ''

for c in f:
    a = f.index(c)
    b = g[:a]
    t = t + (c*len(b))
    
print(t)

2. Indique la salida por pantalla del siguiente código. Justifique su respuesta.

import numpy as np

vector = np.array([1,5,6,6,5,2,1,3,7,9,0,0,1,4,8])

print(np.unique(vector[vector%2==0]).size)

a = vector[vector%2==0]
b = np.unique(a)

print(a)
print(b)
print(b.size)

Referencia: Archivo original 1Eva_IIT2017.pdf

1Eva_IIT2017_T3 Venta combustibles

1ra Evaluación II Término 2017-2018, Diciembre 1, 2017. CCPG001 – FIEC

(Editado para tarea, se mantiene el objetivo de aprendizaje)

Tema 3. (40 puntos) Las ventas anuales (en galones) para las estaciones de gasolina en el país  se muestran en la matriz siguiente:

Ventas Primax Alborada PS Los Rios Mobil Cumbayá Lutexsa Cia Ltda Ps Remigio Crespo
Regular 239034 678493 896321 32438 554213
Extra 4568321 6745634 9754008 3242342 3456123
Super 234773 56743 123678 4783 90874
Premium 45672 45212 90781 3904 90431

Las filas representan el tipo de gasolina y las columnas representan las estaciones de gasolina.

Adicionalmente  dispone de los vectores (en Numpy):

tipoGasolina = np.array(['Regular',
                         'Extra',
                         'Super',
                         ...,
                         'Premium'])
gasolinera = np.array(['Primax Alborada',
                       'PS Los Ríos',
                       'Móbil Cumbayá',
                       'Lutexa Cia Ltda',
                       ...,
                       'PS Remigio Crespo'])
distrito = np.array(['distrito1',
                     'distrito2',
                     'distrito1',
                     'distrito2',
                     ...,
                     'distrito4'])
ciudad = np.array(['Guayaquil',
                   'Babahoyo',
                   'Quito',
                   'Guayaquil',
                   ...,
                   'Cuenca'])

El vector tipoGasolina contiene los nombres de los tipos de gasolina comercializadas en el país.

Los vectores: gasolinera, distrito y ciudad, contienen el nombre de la estación, el distrito y la ciudad en la que se encuentra cada estación. Una ciudad se divide en varios distritos y tiene varias gasolineras, resultando en que los nombres en  distritos y ciudades se pueden repetir en los vectores.

Implemente un programa para responder a las siguientes preguntas:

a) Dado un tipo de gasolina, muestre por pantalla los nombres de todas las gasolineras que han vendido en el año más del promedio de venta en galones para ese tipo.

b) Dada una ciudad, y calcule cuántas de sus gasolineras en el año han vendido más de 15 millones de galones en total , considere todas las ventas para todos los tipos de gasolinas.

c) Muestre por pantalla el nombre de la ciudad que más galones ha vendido en el año de gasolina tipo ‘EcoPais’ en el distrito1.

Nota: Para los literales a y b, los valores de selección se deben ingresar por teclado. El programa se debe realizar en Python.

Rúbrica: literal a (12 puntos), b (13 puntos), c (20 puntos).


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


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

gasolinera  = np.array(['Primax Alborada',
                        'PS Los Ríos',
                        'Móbil Cumbayá',
                        'Lutexa Cia Ltda',
                        'PS Remigio Crespo'])
distrito = np.array(['distrito1',
                     'distrito2',
                     'distrito1',
                     'distrito2',
                     'distrito4'])
ciudad =  np.array(['Guayaquil',
                    'Babahoyo',
                    'Quito',
                    'Guayaquil',
                    'Cuenca'])

Referencia: Archivo original 1Eva_IIT2017.pdf

s1Eva_IIT2017_T3 Venta combustibles

Ejercicio: 1Eva_IIT2017_T3 Venta combustibles

Propuesta de solución en Python:

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

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

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

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

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

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

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

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

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

meta = 5000000

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

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

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

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

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

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

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

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

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

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

Resultado del algoritmo

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