s2Eva_IIT2018_T4 Hielo y especies en Ártico-programa

Finalmente, se crea el programa que usa las funciones anteriores:

# Seccion 4:PROGRAMA
# ----- NUMERAL 1 y 6----- 
matrices = crearMatriz(narchivo)
mhielo09 = matrices[0]
mhielo19 = matrices[1]
manimales09 = matrices[2]
manimales19 = matrices[3]

# ----- NUMERAL 7-----
especies19 = np.unique(manimales19)
k = len(especies19)
comunes = []
for i in range(0,k,1):
    animal = especies19[i]
    Q = cuadrantes(manimales09)
    animal124 = np.concatenate([Q[0],Q[1],Q[3]]) 
    if (animal in animal124) and not(animal in Q[2]):
        comunes.append(animal)
        
# ----- NUMERAL 8-----
migra3 = migracionEspecie(manimales09, manimales19,3)
migro3 = 0
if (migra3[0]!=migra3[1]):
    migro3 =1
# ----- NUMERAL 9-----
# TAREA

# SALIDA
print(' ----- NUMERAL 1 y 6 ----- ')
print('hielo 2009')
print(mhielo09)
print('hielo 2019')
print(mhielo19)
print('animales 2009')
print(manimales09)
print('animales 2019')
print(manimales19)

print(' ----- NUMERAL 7 ----- ')
print('animales comunes: ')
print(comunes)

print(' ----- NUMERAL 8 ----- ')
print('migracion de 3:')
print(migra3)
print('migracion: ',migro3)

print(' ----- NUMERAL 9 ----- ')
print('Tarea...')

s2Eva_IIT2018_T3 Hielo y especies en Ártico-Diccionario

continuación de los temas anteriores:

# ----- NUMERAL 5 -----
def crearDiccionario(mHielo, mAnimales, dicEspecies):
    densidad = densidadHielo(mHielo)
    k = len(densidad)
    tablad = {}
    for i in range(0,k,1):
        indice = 'Q'+str(i+1)
        tablad[indice] = densidad[i]

    especies = list(dicEspecies.keys())
    ke = len(especies)
    tablae = {}
    for j in range(0,ke,1):
        animal = especies[j]
        conteo = poblacionEspecie(mAnimales, animal)
        tablae[animal] = np.sum(conteo)
    
    tabla={}
    tabla['densidad hielo'] = tablad
    tabla['Especies'] = tablae
    return(tabla)

para probar con el computador, se usa el diccionario y los resultados anteriores:

# ----- NUMERAL 5 -----
dicEspecies = {0:'No hay animal',
               1:'Lobo ártico',
               2:'Oso Polar',
               3:'Reno',
               4:'Foca',
               5:'...',
               7:'a7',
               9:'a9',
               22:'a22'}
datosdic = crearDiccionario(mhielo09,
                            manimales09,
                            dicEspecies)

#------------------------------------
print(' ----- NUMERAL 5 ----- ')
print('diccionario para año 2009')
print(datosdic)

con lo que los resultados son:

 ----- NUMERAL 5 ----- 
diccionario para año 2009
{'densidad hielo': {'Q1': 0.5,
                    'Q2': 0.6666666666666666,
                    'Q3': 0.8333333333333334,
                    'Q4': 0.5},
 'Especies': {0: 1,
              1: 7,
              2: 3,
              3: 2,
              4: 6,
              5: 2,
              7: 1,
              9: 1,
              22: 1}
 }

s2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar

Se añade las instrucciones al tema anterior,

Se incluyen las funciones que se asume como existentes para prueba de programa.En caso de problemas o dudas con el conteo, elaborar una función contar.

# 2Eva_IIT2018
# Hielo y especies en Ártico
import numpy as np

# ----- NUMERAL 2 ----- 
# Funciones que suponen que existen:
def cuadrantes(matriz):
    tamano = np.shape(matriz)
    n = tamano[0]
    m = tamano[1]
    mitadfila = n//2
    mitadcolumna = m//2
    Q1 = matriz[0:mitadfila,0:mitadcolumna]
    Q2 = matriz[0:mitadfila,mitadcolumna:]
    Q3 = matriz[mitadfila:,0:mitadcolumna]
    Q4 = matriz[mitadfila:,mitadcolumna:]
    Q = np.array([Q1,Q2,Q3,Q4])
    return(Q)

def poblacionEspecie(mAnimales, especie):
    Q = cuadrantes(mAnimales)
    # pQ1 = np.count_nonzero(Q[0],especie)
    # np.count_nonzero no hay en funciones referencia
    # no en cheatsheet “Cheat Sheet”
    # se procede con algoritmo básico
    k = len(Q)
    poblacion = np.zeros(k,dtype=int)
    for i in range(0,k,1):
        unaQ = Q[i]
        tamano = np.shape(unaQ)
        n = tamano[0]
        m = tamano[1]
        for f in range(0,n,1):
            for c in range(0,m,1):
                if (unaQ[f,c] == especie):
                    poblacion[i] = poblacion[i] +1
    return(poblacion)
# otra forma es usar una funcion contar en arreglo
def contarenarreglo(arreglo,cual):
    tamano = np.shape(arreglo)
    n = tamano[0]
    m = tamano[1]
    contar = 0
    for f in range(0,n,1):
        for c in range(0,m,1):
            if (arreglo[f,c] == cual):
                contar = contar+1
    return(contar)


Desarrollo del numeral 2:

# funcion numeral 2
def densidadHielo(mHielo):
    Q = cuadrantes(mHielo)
    k = len(Q)
    densidad = np.zeros(k,dtype=float)
    for i in range(0,k,1):
        unaQ = Q[i]
        tamano = np.shape(unaQ)
        n = tamano[0]
        m = tamano[1]
        densidad[i]=np.sum(unaQ)/(n*m)
    return(densidad)

desarrollo del numeral 3:

# ----- NUMERAL 3 -----
def especieDominante(mAnimales):
    especies = np.unique(mAnimales)
    ke = len(especies)
    
    Q = cuadrantes(mAnimales)
    k = len(Q)
    dominante = np.zeros(k,dtype=int)
    for i in range(0,k,1):
        unaQ = Q[i]
        cuantos = np.zeros(ke,dtype=int)
        for j in range(0,ke,1):
            # solución semejante al NUMERAL 2
            # para poblacionEspecie
            animal = especies[j]
            cuantos[j] = contarenarreglo(unaQ,animal)
        mayoria = np.argmax(cuantos)
        dominante[i]= especies[mayoria]
    return(dominante)

desarrollo del numeral 4

# ----- NUMERAL 4 -----
def migracionEspecie(mAnimales2009, mAnimales2019, especie):
    Q = cuadrantes(mAnimales2009)
    k = len(Q)
    cuantos = np.zeros(k,dtype=int)
    for i in range(0,k,1):
        unaQ = Q[i]
        cuantos[i] = contarenarreglo(unaQ,especie)
    mayoria09 = np.argmax(cuantos)

    Q = cuadrantes(mAnimales2019)
    k = len(Q)
    cuantos = np.zeros(k,dtype=int)
    for i in range(0,k,1):
        unaQ = Q[i]
        cuantos[i] = contarenarreglo(unaQ,especie)
    mayoria19 = np.argmax(cuantos)
    # considere que numeración desde 0
    a = 'Q'+str(mayoria09+1)
    b = 'Q'+str(mayoria19+1)
    migraron =[a,b]
    return(migraron)


Programa de prueba, incluye las partes del tema anterior

# PROGRAMA DE PRUEBA
# INGRESO
narchivo = 'artico2009-2019.txt'
especie = 4
# PROCEDIMIENTO
# ----- NUMERAL 1 ----- 
matrices = crearMatriz(narchivo)
mhielo09 = matrices[0]
mhielo19 = matrices[1]
manimales09 = matrices[2]
manimales19 = matrices[3]
# ----- NUMERAL 2 ----- 
Q = cuadrantes(manimales09)
poblacion = poblacionEspecie(manimales09, especie)
densidad = densidadHielo(mhielo09)
# ----- NUMERAL 3 -----
dominante = especieDominante(manimales09)
# ----- NUMERAL 4 -----
migraron = migracionEspecie(manimales09, manimales19, especie)


# SALIDA
print(' ----- NUMERAL 1 ----- ')
print('hielo 2009')
print(mhielo09)
print('hielo 2019')
print(mhielo19)
print('animales 2009')
print(manimales09)
print('animales 2019')
print(manimales19)

print(' ----- NUMERAL 2 ----- ')
print('cuadrantes de manimales09')
print(Q)
print('población por cuadrantes de manimales09')
print('para especie = 4')
print(poblacion)
print('densidad de hielo para mhielo09')
print(densidad)

print(' ----- NUMERAL 3 ----- ')
print('dominantes en manimales09')
print(dominante)
print(' ----- NUMERAL 4 ----- ')
print('migraron de la especie: ',especie)
print(migraron)

Los resultados obtenidos son:

animales 2009
[[ 1  2  4  4]
 [ 2  5  5  3]
 [ 1  3  9  1]
 [ 1  1  4  2]
 [ 4 22  4  7]
 [ 1  1  4  0]]

 ----- NUMERAL 2 ----- 
cuadrantes de manimales09
[[[ 1  2]
  [ 2  5]
  [ 1  3]]

 [[ 4  4]
  [ 5  3]
  [ 9  1]]

 [[ 1  1]
  [ 4 22]
  [ 1  1]]

 [[ 4  2]
  [ 4  7]
  [ 4  0]]]
población por cuadrantes de manimales09
para especie = 4
[0 2 1 3]
densidad de hielo para mhielo09
[0.5        0.66666667 0.83333333 0.5       ]
 ----- NUMERAL 3 ----- 
dominantes en manimales09
[1 4 1 4]
 ----- NUMERAL 4 ----- 
migraron de la especie:  4
['Q4', 'Q2']

s2Eva_IIT2018_T1 Hielo y especies en Ártico-Archivo

Usando el archivo proporcionado en el ejemplo: ‘artico2009-2019.txt

se crea la función y programa de prueba con las instrucciones más básicas y simples:

# 2Eva_IIT2018
# Hielo y especies en Ártico
# ----- NUMERAL 1 ----- 
def crearMatriz(narchivo):
    archivo = open(narchivo,'r')
    
    # dimensiones de matriz
    linea = archivo.readline()
    n = int(linea.strip('\n'))
    linea = archivo.readline()
    m = int(linea.strip('\n'))
    # se crean las matrices
    mhielo09 = np.zeros(shape=(n,m),dtype=int)
    mhielo19 = np.zeros(shape=(n,m),dtype=int)
    manimales09 = np.zeros(shape=(n,m),dtype=int)
    manimales19 = np.zeros(shape=(n,m),dtype=int)
    
    # linea encabezados, No procesada
    linea = archivo.readline()
    
    # linea datos
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        anio    =  partes[0]
        fila    = int(partes[1])
        columna = int(partes[2])
        hielo   = int(partes[3])
        animal  = int(partes[4])
        if (anio =='2009'):
            mhielo09[fila,columna] = hielo
            manimales09[fila,columna] = animal
        if (anio =='2019'):
            mhielo19[fila,columna] = hielo
            manimales19[fila,columna] = animal
        linea = archivo.readline()
    archivo.close()
    matrices = [mhielo09,
                mhielo19,
                manimales09,
                manimales19]
    return(matrices)

# PROGRAMA DE PRUEBA
# INGRESO
narchivo = 'artico2009-2019.txt'

# PROCEDIMIENTO
# ----- NUMERAL 1 ----- 
matrices = crearMatriz(narchivo)
mhielo09 = matrices[0]
mhielo19 = matrices[1]
manimales09 = matrices[2]
manimales19 = matrices[3]

# SALIDA
print(' ----- NUMERAL 1 ----- ')
print('hielo 2009')
print(mhielo09)
print('hielo 2019')
print(mhielo19)
print('animales 2009')
print(manimales09)
print('animales 2019')
print(manimales19)

para obtener:

 ----- NUMERAL 1 ----- 
hielo 2009
[[1 0 0 1]
 [0 1 1 1]
 [1 0 1 0]
 [1 1 1 0]
 [0 1 0 1]
 [1 1 1 0]]
hielo 2019
[[1 0 0 1]
 [0 1 0 1]
 [1 0 1 0]
 [1 0 1 0]
 [0 1 0 1]
 [0 0 1 0]]
animales 2009
[[ 1  2  4  4]
 [ 2  5  5  3]
 [ 1  3  9  1]
 [ 1  1  4  2]
 [ 4 22  4  7]
 [ 1  1  4  0]]
animales 2019
[[ 3  2  4  1]
 [ 0 11  3  5]
 [ 1  0 67  1]
 [ 2 22  3  2]
 [13 13  2  3]
 [ 3  0  1  0]]

s2Eva_IT2016_T1 Tendencias en Twitter

Propuesta de solución en Python:

# 2da Evaluación I Término 2016
# Tema 1. 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

Propuesta de solución en Python:

archivo de prueba: meshoratrabajada.txt

# 2da Evaluación I Termino 2018
# Tema 1. Horas extras por empleado
# Propuesta modo simple pero largo
# Tarea: Proponear 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

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
# 2da Evaluación I Termino 2018
# Tema 1. 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[c]
            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)

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.

# 2Eva_IT2018_T1 Niveles seguridad por ciudad
# propuesta de módulo

def cargarDatos(nombrearchivo):
    incidentes = {}
    archivo = open(nombrearchivo, 'r')
    linea = archivo.readline()
    while not(linea ==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        ciud = partes[0]
        robo = partes[1]
        asal = partes[2]
        
        registro = {'robo vehiculo':robo,
                    'asalto':asal}
        incidentes[ciud] = registro

        linea = archivo.readline()
    archivo.close()

    return(incidentes)

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

s2Eva_IIT2016_T2 País destino para jubilados extranjeros

Propuesta de solución en Python:

requiere usar el archivo: destinosdatos.txt

# 2da Evaluación II Término 2016
# Tema 2. País destino para jubilados extranjeros

def cargarDatos(nomFile):
    datos = {}
    archivo = open(nomFile, 'r')
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        
        ciu = partes[0]
        met = partes[1]
        val = float(partes[2])
        
        if not(ciu in datos):
            datos[ciu] = {met:val}
        else:
            datos[ciu][met]= val
        linea = archivo.readline()
        
    archivo.close()
    return(datos)

def metricaPais(datos, paises):
    promedios = {}
    for unpais in paises:
        totalcanasta = 0
        totaltemperatura = 0
        ciudades = paises[unpais]
        
        for unaciudad in ciudades:
            unacanasta = datos[unaciudad]['canastaBasica']
            totalcanasta = totalcanasta + unacanasta
            unatemp = datos[unaciudad]['temperatura']
            totaltemperatura = totaltemperatura + unatemp
        # los promedios son por pais
        promediocanasta = totalcanasta/len(ciudades)
        promediotemperatura = totaltemperatura/len(ciudades)
        promedios[unpais] = {'canastaBasica': promediocanasta,
                             'temperatura': promediotemperatura}  
    return(promedios)

def generaPaises(promedios, metrica, minimo, maximo):
    narchivo = 'cumplencon.csv'
    archivo = open(narchivo, 'w')
    
    for unpais in promedios:
        valor = promedios[unpais][metrica]
        if (valor>=minimo and valor<=maximo):
            linea = unpais +'\n'
            archivo.write(linea)
    archivo.close
    
    mensaje = 'resultados en archivo'
    return(mensaje)


# Programa Prueba
# INGRESO
paises={'Ecuador':{'Cuenca','Guayaquil'},'Colombia':{'Bogotá'}}

nomFile = 'destinosdatos.txt'

metrica = input('cual metrica: ')
minimo = float(input('minimo: '))
maximo = float(input('maximo: '))

# PROCEDIMIENTO
tabla = cargarDatos(nomFile)
promedios = metricaPais(tabla, paises)
cualescumplen = generaPaises(promedios, metrica, minimo, maximo)

# SALIDA
print('tabla de datos: ')
print(tabla)
print('paises')
print(paises)
print('promedios de características')
print(promedios)
print('paises de interes para el jubilado, en archivo')

s2Eva_IIT2017_T1 Citas San Valentin

Propuesta de solución en Python:

# 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

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:

# 2da Evaluación II Término 2017
# Tema 2. reporte comercio internacional
import numpy as np

def calculaTotales(categoria):
    totales = {}

    narchivo = categoria + '.txt'
    archivo = open(narchivo,'r')
    linea = archivo.readline() # Linea de encabezado
    linea = archivo.readline() # Primera linea de datos
    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 + ',' + cate + ',' + prod + ',' + 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 cinco 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)