Ejercicio: 3Eva_IT2018_T2 Producción minera del país

Solución propuesta en Python, el primer bloque corresponde solo a las funciones requeridas en el examen. El segundo bloque corresponde a un programa de prueba.

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IT2018_T2 Producción minera del país
import numpy as np

# Literal a
def extraerMinerales(discurso): 
    palabras = discurso.split(' ')
    cuales   = []

    for unapalabra in palabras:
        # Tarea: verificar únicos
        if 'mral_' in unapalabra:
            mencionados = unapalabra[5:]
            mencionados = mencionados.title()
            cuales.append(mencionados)

    return(cuales)

# literal b
def calcularGanancias(P,C,T,precios):
    produccion = np.array(P)
    costosExtraccion = np.array(C, dtype=float)
    costosTransporte = np.array(T)
    
    # precio en forma de columna
    precios = np.transpose([precios])

    ventas = produccion*precios
    costo = costosTransporte + costosExtraccion
    ganancia = ventas - costo
    return(ganancia)

# literal c
def gananciaTotal(ganancia, minerales):
    ganametal = np.sum(ganancia,axis =1)
    
    ascendente  = np.argsort(ganametal)
    descendente = np.argsort(-ganametal)

    totalmetal  = ganametal[descendente]
    
    # convierte arreglo para ascendente
    minerales = np.array(minerales)
    cualmetal = minerales[descendente]

    ganatotal = (totalmetal,list(cualmetal))

    return(ganatotal)

# literal d
def top8(discurso,reporte):
    mencionados = extraerMinerales(discurso)
    totalmetal  = reporte[0]
    cualmetal   = reporte[1]
    
    interseccion = []
    m = len(cualmetal)
    for i in range(0,m,1):
        if (cualmetal[i] in mencionados):
            interseccion.append(cualmetal[i])
            
    mejoresmencionados = interseccion[:8]
    return (mejoresmencionados)

Programa de Prueba

Observación: las matrices C y T no tienen el mismo orden de magnitud a pesar de ser costos totales. Podría ser que el costo de extracción C sea por gramos, sin embargo las matrices se usan tal como fueron presentadas en el examen

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

# PROGRAMA DE PRUEBA -----
discurso  = 'y el dia de ayer descubrimos en la mina mirador que la cantidad de mral_oro'

minerales = ['Oro', 'Plata', 'Cobre']
precios   = [38.48,    3.43,    0.01]

minas = ['MIRADOR', 'FRUTA_DEL_NORTE', 'LOMA_LARGA', 'otra']


P = [[ 13524000, 121072000,  1204000,  9632000],
     [ 28000000,    952000,  9632000, 96404000],
     [126980000,    896000, 92988000,  9604000]]

C = [[ 12.32, 10.23, 23.23, 19.23],
     [  3.13,  1.78,  2.45,  1.69],
     [  8.32,  5.25,  6.32,  6.89]]

T = [[ 43736616, 341786256,  5442080,  28241024],
     [ 76244000,   1827840, 13966400, 435746080],
     [156439360,   1121792,300723192,  10785292]]
            
# PROCEDIMIENTO
mencionados = extraerMinerales(discurso)

ganancias  = calcularGanancias(P,C,T,precios)

ganatotal  = gananciaTotal(ganancias, minerales)
totalmetal = ganatotal[0]
cualmetal  = ganatotal[1]

mejoresmencionados = top8(discurso,ganatotal)


# SALIDA
print('a) los minerales mencionados son: ')
print(mencionados)

print('b) las ganancias totales son:')
print(ganancias)

print('c) ganancias totales por metal')
print(totalmetal)
print(cualmetal)

print('d) los 8 mejores mencionados: ')
print(mejoresmencionados)

los resultados en pantalla son :

a) los minerales mencionados son: 
['Oro']
b) las ganancias totales son:
[[  4.76666892e+08   4.31706429e+09   4.08878168e+07   3.42398317e+08]
 [  1.97959969e+07   1.43751822e+06   1.90713576e+07  -1.05080362e+08]
 [ -1.55169568e+08  -1.11283725e+06  -2.99793318e+08  -1.06892589e+07]]
c) ganancias totales por metal
[  5.17701732e+09  -6.47754890e+07  -4.66764983e+08]
['Oro', 'Plata', 'Cobre']
d) los 8 mejores mencionados: 
['Oro']
>>> 

Ejercicio: 3Eva_IT2018_T1 Choferes y Rutas Trailers

Propuesta en Python, se incluye la función calcularFecha() se presenta para poder probar las funciones en el programa de prueba.

El archivo con datos de prueba usado es: rutasManejadas2018.txt

La propuesta considera el uso de listas, por ser parte de los ejercicios del proyecto para 3ra Evaluación.

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IT2018_T1 Choferes y Rutas Trailers

# literal a
def cargarDatos(narchivo):
    loschoferes = []
    tabla = {}
    
    archivo  = open(narchivo,'r')
    cabecera = archivo.readline()
    linea = archivo.readline()
    while not(linea==''):
        linea  = linea.strip('\n')
        partes = linea.split(',')
        ruta   = partes[0]
        chofer = partes[1]
        fecha  = partes[2]
        
        if not(chofer in loschoferes):
            loschoferes.append(chofer)

        if not(fecha in tabla):
            tabla[fecha] = {ruta:[chofer]}
        else:
            if not(ruta in tabla[fecha]):
                tabla[fecha][ruta] = [chofer]
            else:
                tabla[fecha][ruta].append(chofer)
                
        linea = archivo.readline()
        
    archivo.close()

    return((loschoferes,tabla))

# función para pruebas, no requerida en la evaluación
import datetime as dtt

def calcularFecha(unafecha,n):
    formato = '%d-%m-%Y'
    fecha   = dtt.datetime.strptime(unafecha,formato)
    pasada  = fecha - dtt.timedelta(days=n)
    pasadatxt = dtt.datetime.strftime(pasada,formato)
    return(pasadatxt)

# literal b
def encontrarChoferes(tabla,loschoferes,unafecha,unaruta,n):
    simanejaron = []
    fechas = list(tabla.keys())
    for i in range(1,n+1,1):
        pasada = calcularFecha(unafecha,i)
        if (pasada in fechas):
            trabajaron = tabla[pasada][unaruta]
            for unchofer in trabajaron:
                if not(unchofer in simanejaron):
                    simanejaron.append(unchofer)
    nomanejaron = []
    for unchofer in loschoferes:
        if not(unchofer in simanejaron):
            nomanejaron.append(unchofer)
    return(nomanejaron)

# literal c
def grabarArchivo(tabla,loschoferes,unafecha,n):  
    narchivograba = unaruta+'_'+unafecha+'_'+str(n)+'.txt'
    
    archivo = open(narchivograba,'w')
    
    cabecera = 'Para la ruta '+unaruta+'\n'
    cabecera = cabecera + 'los choferes disponibles para la fecha '+unafecha+'\n'
    cabecera = cabecera + 'que no hayan manejado '+str(n)+' dias anteriores son: \n'
    archivo.write(cabecera)
    
    nomanejaron = encontrarChoferes(tabla,loschoferes,unafecha,unaruta,n)

    for cadachofer in nomanejaron:
        archivo.write(cadachofer+'\n')
    archivo.close()
    
    return(narchivograba)

programa de prueba, como trabajo extra, no requerido para el examen:

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# PROGRAMA PRUEBA -------
# INGRESO
narchivo = 'rutasManejadas2018.txt'
unafecha = '19-05-2018'
unaruta = 'Guayaquil-Cuenca'
n = 2

# PROCEDIMIENTO
datos = cargarDatos(narchivo)
loschoferes = datos[0]
tabla = datos[1]
nomanejaron = encontrarChoferes(tabla,loschoferes,unafecha,unaruta,n)
elarchivo = grabarArchivo(tabla,loschoferes,unafecha,n)

# SALIDA
print('a) los choferes registrados son: ')
print(loschoferes)
print('   la tabla de trabajos es: ')
print(tabla)
print('b) los choferes que no manejaron en ')
print('  '+unaruta+', '+str(n)+' dias antes del '+unafecha+': ')
print(nomanejaron)
print('c) resultados en el archivo: ', elarchivo)

Se muestra el resultado en pantalla del programa usando los datos de prueba del archivo:

a) los choferes registrados son: 
['SMS', 'AGB', 'SMZ', 'EVN', 'AAQ']
   la tabla de trabajos es: 
{'17-05-2018': {'Guayaquil-Cuenca': ['SMS', 'SMZ'], 'Guayaquil-Daule': ['EVN']}, '18-05-2018': {'Guayaquil-Cuenca': ['AGB'], 'Guayaquil-Daule': ['AAQ']}}

b) los choferes que no manejaron en 
  Guayaquil-Cuenca, 2 dias antes del 19-05-2018: 
['EVN', 'AAQ']

c) resultados en el archivo:  Guayaquil-Cuenca_19-05-2018_2.txt
>>> 

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)

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)

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.

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

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

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)

Ejercicio: 1Eva_IT2018_T2 Desempeño de jugadores mundial futbol

Propuesta de solución en Python:

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 pais 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']]

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 eneuentra en la tabla.

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)