Autor: Edison Del Rosario

3Eva_IIT2017_T2 Biblioteca videojuegos
3ra Evaluación II Término 2017-2018. Febrero 23, 2018 /CCPG001

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

Tema 2. (50 puntos) Suponga que tiene el archivo "videojuegos.csv"con información sobre todo el contenido de su biblioteca de videojuegos.

El archivo tiene la siguiente estructura:
```
videojuegos.csv
Nombre, Año, Consola, Calificación, Tags (separados por ;)
The Legend of Zelda,86,Famicon Disk System,3.5,RPG;Link;Zelda;Hyrile;Triforce
Double Dragon,87,Arcade,3.7,Beat-em up; Billy;Jimmy;Puñete
The Legend of Zelda,88,NES,4.3,RPG;Link;Zelda;Hyrule;Triforce
...
Halo 5:Guardians,15,Xbox One,4,FPS;Master Chief;Cortana;Covenant
```
Note que un juego aparecerá listado en el archivo una vez por cada consola en la que fué lanzado.
La categoría del juego se especifica siempre en el primer Tag. Por ejemplo, Double Dragon pertenece a la categoriía Beat-'em up.

Desarrolle lo siguiente:

a) La función juegosConsolas(nomArchivo, categoria, decada) que recibe el nombre del archivo con la información de los videojuegos, una categoría y número de cuatro dígitos representando una década de años. La función retoma una tupla con 2 elementos. El primer elemento es la lista con los valores únicos de todos lo juegos de esa década para esa categoría. El segundo elemento es la lista con valores únicos de todas las consolas que tienen juegos para esa década y categoría.

Por ejemplo, para llamar a juegosConsolas('videojuegos.csv','RPG',1980) retorna:
```
(['The legend of Zelda',  'Phantasy Star', ...], ['NES', 'Famicon Disk System', ...])
```
b) La función crearMatriz(nomArchivo, categoria, decada) que recibe el nombre del archivo con la información de los videojuegos, el nombre de una categoría de videojuegos y un número de cuatro dígitos representando una década de años. La función deberá leer el archivo y retornar una matriz donde las filas representan los juegos de categoria para la decada , las columnas representan las consolas que tienen juegos de categoria para la decada y las celdas son las calificaciones de cada juego para cada consola. Si un juego no existe para una consola, su calificación deberá ser cero (0).

c) La función mejoresJuegos(nomArchivo, categoria, decada) que recibe el nombre del archivo con la información de los videojuegos, el nombre de una categoría de videojuegos y un número de cuatro dígitos representando una década de años. La función deberá generar el archivo “Mejores.txt” con los cinco mejores juegos de la decada para la categoria , ordenados de mayor a menor por su calificación promedio. Para calcular el promedio de un juego, considere únicamente las consolas en las que fue lanzado (no considere los valores cero). El archivo tendrá la siguiente estructura:
```
NombreNombre,Promedio_calificación
```
d) La función colecciones(nomArchivo, palabras) que recibe el nombre del archivo con la información de los videojuegos y una lista de palabras. La función deberá retornar otra lista de valores únicos con los nombres de todos los juegos que sus Tags contengan todos los términos de la lista palabras .

Rúbrica: literal a (15 puntos), literal b (17 puntos), literal c (18 puntos), literal d Bono (5 puntos)

Referencia: Archivo original 3Eva_IIT2017.pdf
2018-02-24
3Eva_IIT2017_T1 Mantenimiento vehículos
3ra Evaluación II Término 2017-2018. Febrero 23, 2018 /CCPG001

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

Tema 1. (40 puntos) CuidaVehículo.com requiere una aplicación para gestionar el mantenimento vehículos clasificados por tipo: 'preventivos' y 'correctivos' .

Dispone de la tabla de mantenimientos recomendados por tipo para cada parte del vehículo. La tabla contiene los parámetros que considera el número de días y recorrido en Kilómetros desde el último mantenimiento.

El historial registra la placa del vehículo, el cliente, parte, tiempo y recorrido desde el último mantenimiento.

Las tablas son siempre usadas como parámetros de ingreso en las funciones y se almacenan en diccionarios con la estructura mostrada:
```
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)]
        }
    }
```
a) Elabore una función mantenimientos(strPlaca, dictHistorial, dictMantenimiento) que dada una placa de vehículo, realiza una lista de las partes con el tipo de mantenimiento recomendado: 'preventivo', 'correctivo' o 'ninguno'.

Solo un tipo de mantenimiento se realiza para cada parte del vehículo, considerando siempre el parámetro de recorrido en Kilómetros. En el caso que una parte supera el parámetro para ambos tipos de mantenimiento, se da prioridad al mantenimiento 'correctivo'.

El resultado es una lista de tuplas con las partes y tipo de mantenimiento.

b) Escriba una función semaforo(strPlaca, dictHistorial, dictMantenimiento) que establece un código de colores para cada tipo de mantenimiento: , amarillo: 'preventivo' , rojo: 'correctivo' y verde: 'ninguno'.

El resultado es un diccionario que tiene como clave el color y como datos una lista con las partes correspondientes a cada tipo de mantenimiento.

c) Realice una función recomendar(strparte, strtipoMantenimiento, dictHistorial, dictMantenimiento) que entrega una lista de placas de vehículos que requieren el tipo de mantenimiento para una parte dada.

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

Referencia: Archivo original 3Eva_IIT2017.pdf
2018-02-24
3Eva_IIT2017_T3 Prueba de escritorio, listas
3ra Evaluación II Término 2017-2018. Febrero 23, 2018 /CCPG001

Tema 3. (10 puntos)

a) Considere las siguente instrucciones en python. Justifique su respuesta de la salida en pantalla.
```
a = 'ABACDEF'
b = [4,2,1,3,2,2,3]

d = ''
for i in a:
    if i not in d:
        d += i*b[ list(a).index(i)]
    else:
        d = d.replace(i,'')
        
print(d)
```
b) indique la salida por pantalla de las siguientes instrucciones en python. Justifique su respuesta
```
a = [1,3,5,6,8]

b = []
for i in range(len(a)):
    b.append(i)
    b.insert(i,len(b))

print(b)
```
Referencia: Archivo original 3Eva_IIT2017.pdf
2018-02-24

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)

2018-02-24

2Eva_IIT2017_T1 Citas San Valentín
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
2018-02-15
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
2018-02-15
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ía 'Flores', '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.txt, Maderas.txt
para obtener respuestas: categoriasconsolidado.txt, totalFlores, totalMaderas
2018-02-15

s2Eva_IIT2017_T1 Citas San Valentín

Ejercicio: 2Eva_IIT2017_T1 Citas San Valentín

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)

2018-02-15

s2Eva_IIT2017_T2 reporte comercio internacional

Ejercicio: 2Eva_IIT2017_T2 Reporte comercio internacional

Propuesta de solución en Python:

archivos usados: Flores.txt, Maderas.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)

2018-02-15

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 en Python

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

2018-02-11

Autor: Edison Del Rosario

3ra Evaluación II Término 2017-2018. Febrero 23, 2018 /CCPG001

3ra Evaluación II Término 2017-2018. Febrero 23, 2018 /CCPG001

3ra Evaluación II Término 2017-2018. Febrero 23, 2018 /CCPG001

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

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

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

Algoritmo en Python