Etiqueta: fundamentos programacion

fundamentos de programación con Python.

  • s2Eva_IT2016_T1 Tendencias en Twitter

    Ejercicio: 2Eva_IT2016_T1 Tendencias en Twitter

    Propuesta de solución en Python:

    # CCPG1001-Fundamentos de programación FIEC-ESPOL
    # 2Eva_IT2016_T1 Tendencias en Twitter
    
    def reportatendencia(tendencias,fecha1,fecha2):
        etiquetasf1 = tendencias[fecha1]
        n = len(etiquetasf1)
        etiquetasf2 = tendencias[fecha2]
        m = len(etiquetasf2)
        difsimetrica =[]
        i = 0
        while not(i>=n):
            # TAREA
    
            i = i + 1  
        return(difsimetrica)
    
    def cuentaTopics(tendencias, listaFechas):
        fechaslista = list(listaFechas)
        n = len(fechaslista)
        union = {}
        i = 0
        while not(i>=n):
            etiquetas = tendencias[fechaslista[i]]
            etiquetas = list(etiquetas)
            m = len(etiquetas)
            j = 0
            while not(j>=m):
                if not(etiquetas[j] in union):
                    union[etiquetas[j]]=0
                j = j + 1
            i = i + 1
            
        # contadores
        i = 0
        while not(i>=n):
            etiquetas = tendencias[fechaslista[i]]
            etiquetas = list(etiquetas)
            m = len(etiquetas)
            j = 0
            while not(j>=m):
                cual = etiquetas[j]
                union[cual] = union[cual] + 1
                j = j + 1
            i = i + 1
    
        return(union)
    
    tendencias = {
        '08-22-2016':{'#Rio2016', '#BSC', '#ECU'},
        '08-25-2016':{'#GYE', '#BRA'},
        '08-27-2016':{'#YoSoyEspol', '#GYE', '#BSC'}
        }
    
    listaFechas = ['08-22-2016','08-27-2016']
    # PROCEDIMIENTO
    cuales = cuentaTopics(tendencias, listaFechas)
    
    print(cuales)
    
  • s2Eva_IT2018_T2 Pago nomina mensual

    Ejercicio: 2Eva_IT2018_T2 Pago nomina mensual

    Propuesta de solución en Python:

    archivo de prueba: meshoratrabajada.txt

    # CCPG1001-Fundamentos de programación FIEC-ESPOL
    # 2Eva_IT2018_T2 Pago nomina mensual
    # Propuesta modo simple pero larga
    # Tarea: Proponer simplificaciones a los algoritmos
    
    def calcularHoras(linea):
        linea  = linea.strip('\n')
        partes = linea.split(',')
        fecha  = partes[0]
        dia = int(partes[1])
        esferiado = partes[2]
        ID = partes [3]
        nombre   = partes[4]
        sucursal = partes[5]
        ciudad   = partes[6]
        horas    = int(partes[7])
    
        trabajado = [ID,ciudad, 0,0,0,0]
        if (esferiado=='Si'):
            trabajado[5] = horas
        else:
            if (dia>=6):
                trabajado[4] = horas
            else:
                if (horas<=8):
                    trabajado[2] = horas
                else:
                    trabajado[2] = 8
                    trabajado[3] = horas-8
        return(trabajado)
    
    def leerData(nomA):
        
        total = {}
        archivo = open(nomA,'r')
        # factores
        linea = archivo.readline()
        linea = linea.strip('\n')
        partes = linea.split(',')
        VH = float(partes[1])
        
        linea = archivo.readline()
        linea = linea.strip('\n')
        partes = linea.split(',')
        
        HR = float(partes[1])
        linea = archivo.readline()
        linea = linea.strip('\n')
        partes = linea.split(',')
        
        HER = float(partes[1])
        linea = archivo.readline()
        linea = linea.strip('\n')
        partes = linea.split(',')
        
        HFDS = float(partes[1])
        linea = archivo.readline()
        linea = linea.strip('\n')
        partes = linea.split(',')
        HF = float(partes[1])
        
        # encabezado
        linea = archivo.readline()
        
        # datos    
        linea = archivo.readline()
        parafecha = linea.split(',')
        parafecha = parafecha[0].split('-')
        mes = parafecha[1]
        anio = parafecha[2]
        
        while not(linea==''):
            trabajado = calcularHoras(linea)
            ID = trabajado[0]
            ciudad = trabajado[1]
            normal = trabajado[2]*VH*HR
            extra = trabajado[3]*VH*HER
            finsem = trabajado[4]*VH*HFDS
            feriado = trabajado[5]*VH*HF
            
            if not(ciudad in total):
                total[ciudad] = {ID:{'HR': normal,
                                    'HER': extra,
                                    'HFDS': finsem,
                                    'HF': feriado}}
            else:
                if not(ID in total[ciudad]):
                    total[ciudad][ID] = {'HR': normal,
                                         'HER': extra,
                                         'HFDS': finsem,
                                         'HF': feriado}
                else:
                    total[ciudad][ID]['HR'] = total[ciudad][ID]['HR'] + normal
                    total[ciudad][ID]['HER'] = total[ciudad][ID]['HER'] + extra
                    total[ciudad][ID]['HFDS'] = total[ciudad][ID]['HFDS'] + finsem
                    total[ciudad][ID]['HF'] = total[ciudad][ID]['HF'] + feriado
            linea = archivo.readline()     
        
        archivo.close()
        pagonomina = (total,mes,anio)
        return(pagonomina)
    
    def generareporte(nomA):
        pagonomina = leerData(nomA)
        total  = pagonomina[0]
        mes    = pagonomina[1]
        anio   = pagonomina[2]
        ciudad = list(total.keys())
        
        for lugar in ciudad:
            narchivo = lugar+mes+'-'+anio+'.txt'
            archivo  = open(narchivo,'w')
            registro = total[lugar]
            # Tarea: Poner encabezado
            
            for empleado in registro:
                linea = empleado +','+str(total[lugar][empleado]['HR'])
                extra = total[lugar][empleado]['HER']+ total[lugar][empleado]['HFDS'] +total[lugar][empleado]['HF']
                linea = linea+','+str(extra)+'\n'
                archivo.write(linea)
                
            archivo.close()
        mensaje = 'archivo guardado'
        return(mensaje)
    
    # PROGRAMA PRUEBA -------------------
    # INGRESO
    nomA = 'meshoratrabajada.txt'
    
    # PROCEDIMIENTO
    mensaje = generareporte(nomA)
    
    # SALIDA
    print(mensaje)
    
  • s2Eva_IT2018_T1 Niveles seguridad por ciudad

    Ejercicio: 2Eva_IT2018_T1 Niveles seguridad por ciudad

    Propuesta de solución en Python:

    Como referencia para el algoritmo se usa la tabla:

    incidentes
    ciudad robo vehículos asalto
    Guayaquil 605 6345
    Cuenca 123 676

    El módulo cargarDatos() desde un archivo se guarda como ecu911.py
    La sección no era necesario escribirla en la evaluación, se podría suponer que ya estaba escrita.

    Algoritmo en Python

    # CCPG1001-Fundamentos de programación FIEC-ESPOL
    # 2Eva_IT2018_T1 Niveles seguridad por ciudad
    import numpy as np
    import ecu911 es ecu
    
    def titulostabla(tabla_dic):
        ciudad = tabla_dic.keys()
        ciudad = list(ciudad)
        
        unaciudad = ciudad[0]
        unregistro = tabla_dic[unaciudad]
        
        tipodelito = unregistro.keys()
        tipodelito = list(tipodelito)
        
        titulos = [ciudad,tipodelito]
        return(titulos)
    
    def crearMatriz(tabla_dic,titulos):
        ciudad = titulos[0]
        tipodelito = titulos[1]
        n = len(ciudad)
        m = len(tipodelito)
        
        tabla = np.zeros(shape=(n,m),dtype = int)
        f = 0
        while not(f>=n):
            c = 0
            unaciudad = ciudad[f]
            registro = tabla_dic[unaciudad]
            while not(c>=m):
                untipo = tipodelito
                valor = registro[untipo]
                tabla[f,c] = valor
                c = c+1
            f = f+1
            
        return(tabla)
    
    def ciudadesMenosSeguras(matriz, titulos, untipo, poblacion):
        ciudad = titulos[0]
        tipodelito = titulos[1]
        
        columna = tipodelito.index(untipo)
        incidentes = matriz[:,columna]
        indicador = incidentes/poblacion
    
        cual = np.argmax(indicador)
        insegura = ciudad[cual]
        # Tarea: encontrar las siguientes menos seguras
        return(insegura)
    
    # PROGRAMA PRUEBA -------------------
    # INGRESO
    
    nombrearchivo = 'reporteincidentes.txt'
    tabla = ecu.cargardatos(nombrearchivo)
    
    # Usado si no dispone del módulo y archivo.txt
    #tabla_dic = {
    #    'Guayaquil':{'robo vehiculo':605, 'asalto':6345},
    #    'Cuenca':   {'robo vehiculo':123, 'asalto': 676}
    #    }
    poblacion = np.array([2000, 1000])
    untipo = 'asalto'
    
    # PROCEDIMIENTO
    titulos = titulostabla(tabla_dic)
    matriz = crearMatriz(tabla_dic,titulos)
    inseguras = ciudadesMenosSeguras(matriz, titulos, untipo, poblacion)
    
    # SALIDA
    print('Los títulos de la tabla son:')
    print(titulos)
    print('La matriz de datos: ')
    print(matriz)
    print('La menos segura: ')
    print(inseguras)
    

    Usando el módulo es necesario disponer de un archivo reporteincidentes.txt con datos, por facilidad en el mismo directorio de trabajo:

    Guayaquil,605,6345
    Cuenca,123,676
    
  • s1Eva_IT2018_T1 Busca especie con ADN

    Ejercicio: 1Eva_IT2018_T1 Busca especie con ADN

    Propuesta de solución en Python:

    primero se obtiene una secuencia del listado

    i = 0
    secuencia = Listado[i]

    Para obtener la inversa se empieza copiando desde el último caracter de la secuencia con índice j=m-1, siendo m la cantidad de caracteres de la secuencia.

    # calcula la inversa
    m = len(secuencia)
    inversa = ''
    j = m-1
    while not(j<0):
        inversa = inversa + secuencia[j]
        j = j-1
    

    el resultado esperado es:

    las secuencias que pertenecen son:  1
    Secuencia:  ATTTGCTTGCTATTTAAACCGGTTATGCATAGCGC
    indices de inversa: [0, 2, 7, 25, 29]
    >>> 
    

    El análisis se realiza en dos partes: desde j=0 hasta mitad = m//2. Luego desde la mitad hasta m.

    Al comparar la referencia con una sección de la inversa, se pueden almacenar los índices de la coincidencia en otra lista.

    Algoritmo en Python

    # CCPG1001 Fundamentos de Programación FIEC-ESPOL
    # 1Eva_IT2018_T1 Busca especie con ADN
    # propuesta de solución: edelros@espol.edu.ec
    
    # INGRESO
    Listado = ['ATTTGCTTGCTATTTAAACCGGTTATGCATAGCGC', 
               'ATTAGCCGCTATCGA']
    Referencia = 'CG'
    
    # PROCEDIMIENTO
    n = len(Listado)
    tref = len(Referencia)
    pertenece = []
    
    i = 0
    while not(i>=1):
        secuencia = Listado[i]
        indices   = []
        
        # calcula la inversa
        m = len(secuencia)
        inversa = ''
        j = m-1
        while not(j<0):
            inversa = inversa + secuencia[j]
            j = j-1
            
        # Analiza las partes, mitad
        mitad  = m//2
        veces1 = 0
        veces2 = 0
       
        j = 0    # primera mitad
        while not(j>=mitad):
            seccion = inversa[j:j+tref]
            if (seccion == Referencia):
                veces1 = veces1 + 1
                indices.append(j)
            j = j + 1
    
        j = mitad    # segunda mitad
        while not(j>=m):
            seccion = inversa[j:j+tref]
            if (seccion == Referencia):
                veces2 = veces2 + 1
                indices.append(j)
            j = j + 1
    
        # Revisa si pertenece a especie
        total = veces1 + veces2
        if (veces2==2 and total>=4):
            pertenece.append([secuencia, indices])
    
        # siguiente secuencia de listado
        i = i + 1 
    
    # SALIDA
    # print(pertenece)
    tp = len(pertenece)
    print('las secuencias que pertenecen son: ', tp)
    i = 0
    while not(i>=tp):
        print('Secuencia: ',pertenece[i][0])
        print('indices de inversa:',pertenece[i][1])
        i = i + 1
    

    Tarea: Convertir a funciones las secciones de:

    - Inversa de la secuencia creainversa(secuencia)

    - Conteo de referencias en mitades de secuencia cuentareferencia(mitadsecuencia)

    - Crear vector de índices donde se encuentra la referencia entregaindices(inversa)

  • s1Eva_IT2018_T2 Desempeño de jugadores mundial futbol

    Ejercicio: 1Eva_IT2018_T2 Desempeño de jugadores mundial futbol

    Revisar las sugerencias en el enunciado, dividir el problema y simplificar las tablas para las pruebas de algoritmos, con lo que que se obtiene:

    a) el país con mas goles promedio:  Argentina
    b) los jugadores efectivos de:  Brasil 0
    c) jugadores amarrabalon:  ['Lionel Messi']
    d) jugador con más pases acertados:  Lionel Messi
    e) promedios mundiales:  [  33.66666667   88.33333333   64.          179.33333333]
    f) : Lionel Messi no está por encima del promedio mundial
    >>> 
    

    visualizar la tabla de paises_jugadores es:

    >>> pais_jugadores
    [['Cristiano Ronaldo'], 
     ['Neymar Jr.'], 
     ['Lionel Messi']]
    

    Algoritmo en Python

    las instrucciones desarrolladas por literal son:

    # CCPG1001 Fundamentos de Programación FIEC-ESPOL
    # 1Eva_IT2018_T2 Desempeño de jugadores mundial futbol
    import numpy as np
    
    # INGRESO
    desempeno = np.array([[ 32, 24, 45],
                          [ 90, 84, 91],
                          [ 54, 60, 78],
                          [187,239,112]])
    
    paises = ['Portugal', 'Brasil', 'Argentina']
    prtgl  = ['Cristiano Ronaldo']
    brsl   = ['Neymar Jr.' ]
    argntn = ['Lionel Messi']
    
    pais_jugadores = [prtgl, brsl, argntn]
    
    analizapais = 'Brasil'
    analizaposeebalon = 76
    analizajugador = 'Lionel Messi'
    
    # PROCEDIMIENTO
    tamano = np.shape(desempeno)
    tdf    = tamano[0]
    tdc    = tamano[1]
    tp     = len(paises)
    
    # tabla ubicapais[unpais] = [desde,hasta,cuantos]
    ubicapais = np.zeros(shape=(tp,3),dtype=int)
    desde  = 0
    unpais = 0
    while not(unpais>=tp):
        jugadores = pais_jugadores[unpais]
        cuantos   = len(jugadores)
        hasta     = desde + cuantos
        ubicapais[unpais,0] = desde
        ubicapais[unpais,1] = hasta
        ubicapais[unpais,2] = cuantos
        desde  = hasta
        unpais = unpais + 1
        
    # Agrupa jugadores
    todosjugadores = []
    unpais =  0
    while not(unpais>=tp):
        jugadores = pais_jugadores[unpais]
        cuantos   = len(jugadores)
        quien = 0
        while not(quien>=cuantos):
            todosjugadores.append(jugadores[quien])
            quien = quien + 1
        unpais = unpais +1
    
    # a) pais con mas goles promedio
    fila = 0 # fila goles anotados
    golesanotados = desempeno[fila]
    prmGolAnota = np.zeros(tp,dtype = float)
    unpais = 0
    while not(unpais>=tp):
        desde   = ubicapais[unpais,0]
        hasta   = ubicapais[unpais,1]
        cuantos = ubicapais[unpais,2]
        
        golpais = golesanotados[desde:hasta]
        prmGolAnota[unpais] = np.sum(golpais)/cuantos
        
        unpais = unpais + 1
        
    goleador = np.argmax(prmGolAnota)
    nombregoleador = paises[goleador]
    
    # b) Contar jugadores con mayor efectividad
    # al promedio de analizapais
    # donde = paises.index(buscapais)
    donde  = -1
    unpais = 0
    while not(unpais>=tp or donde>=0):
        if (paises[unpais] == analizapais):
            donde = unpais
        unpais = unpais + 1
    
    # efectividad del pais analizado
    fila = tdf-1 # tiros al arco (última de desempeno)
    tirosdirectos = desempeno[fila]
    
    desde = ubicapais[donde,0]
    hasta = ubicapais[donde,1]
    
    anotados = golesanotados[desde:hasta]
    directos = tirosdirectos[desde:hasta]
    efectivopais = np.sum(anotados)/np.sum(directos)
    
    #jugadores efectivos del pais analizado
    cuentaefectivos = 0
    quien = desde
    while not(quien>=hasta):
        unaefectividad = golesanotados[quien]/tirosdirectos[quien]
        if (unaefectividad > efectivopais):
            cuentaefectivos = cuentaefectivos+1
        quien = quien + 1
    
    # c) posesion balón
    fila = 2 # fila de posesión de balón
    poseebalon = desempeno[fila]
    amarrabalon = []
    quien = 0
    while not(quien>=tdc):
        if (poseebalon[quien]>analizaposeebalon):
            amarrabalon.append(todosjugadores[quien])
        quien = quien +1
        
    # d) jugador con más pases acertados
    fila = tdf-2
    pasesacertados = desempeno[fila]
    quienacierta   = np.argmax(pasesacertados)
    nombreacierta  = todosjugadores[quienacierta]
    
    # e) promedios mundiales
    promediomundial = np.sum(desempeno,axis =1)/tdc
    
    # f) jugadores superior a promedio mundial
    # donde = todosjugadores.index(analizajugador)
    donde = -1
    quien = 0
    while not(unpais>=tp or donde>=0):
        if (todosjugadores[quien] == analizajugador):
            donde = unpais
        quien = quien + 1
    
    # verifica cumplimiento de parámetros
    cumple = ' está '
    fila = 0
    while not(fila>=tdf):
        caracteristica = desempeno[fila,donde]
        if (caracteristica< promediomundial[fila]):
            cumple = ' no está '
        fila = fila+1
    mensaje = analizajugador + cumple + 'por encima del promedio mundial'
    
    # SALIDA
    print('a) pais con mas goles promedio: ', nombregoleador)
    print('b) jugadores efectivos de: ', analizapais, cuentaefectivos)
    print('c) jugadores amarrabalon: ', amarrabalon)
    print('d) jugador con más pases acertados: ', nombreacierta)
    print('e) promedios mundiales: ', promediomundial)
    print('f) :', mensaje)

    Tarea: Realice las modificaciones necesarias para realizar las funciones para las secciones de:

    - crear tabla ubicapais(paises_jugadores)

    - agrupajugadores(paises_jugadores)

    use las funciones realizadas en el programa.

    Considerar cuando la respuesta de los algoritmos de búsqueda es -1, no se encontró el elemento en el conjunto. En la propuesta no se valida ésta situación, por ejemplo, si se pone 'espana' y no se encuentra en la tabla.

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