Propuesta de solución en Python:

Como referencia para el algoritmo se usa la tabla:

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)