Categoría: Sol_3Eva 2016-2017-2018

Ejercicio: 3Eva_IT2017_T2 Huracanes en Atlantico Norte

Propuesta de solución en Python:

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IT2017_T2 Huracanes en Atlantico Norte
# Supone que el numero de columnas de M
# Es igual al numero de nombres en huracanes

import numpy as np

def categoriza(M):
    tamano = np.shape(M)
    n = tamano[0]
    m = tamano[1]
    categoria = np.ones(m, dtype=int)
    for j in range(0,m,1):
        vv = M[2,j]
        if (vv>=100 and vv=150 and vv=200 and vv250):
            categoria[j]=5
    return(categoria)

def total_marejada(M,cat):
    categoria = categoriza(M)
    
    tamano = np.shape(M)
    n = tamano[0]
    m = tamano[1]

    marejadas = np.zeros(6,dtype=float)
    for j in range(0,m,1):
        k = categoria[j]
        marejadas[k] = marejadas[k]+M[4,j]
    totaluna = marejadas[cat]
    return(totaluna)

def indices_anio(huracanes,anio):
    # Supone que cantidad de huracanes
    # es igual a columnas de matriz
    cuales  = huracanes.keys()
    indices = {}
    a = 0
    b = -1
    for cada in cuales:
        m = len(huracanes[cada])
        a = b + 1
        b = a + m-1
        indices[cada] = [a,b]
    return(indices[anio])

def velocidad_superior(M,huracanes,anio):
    cual   = indices_anio(huracanes,anio)
    desde  = cual[0]
    hasta  = cual[1]
    vector = M[0,desde:hasta+1]
    promedio = np.mean(vector)
    cuantos = 0
    for valor in vector:
        if (valor>promedio):
            cuantos = cuantos + 1
    return(cuantos)

def ACE(M,huracanes,anio):
    cual   = indices_anio(huracanes,anio)
    desde  = cual[0]
    hasta  = cual[1]
    vector = M[0,desde:hasta+1]
    liberada = 0
    for valor in vector:
        liberada = liberada + valor**2
    liberada = liberada*(10**(-4))
    return(liberada)

def lluvia(M, huracanes, nombre_huracan,anio):
    nombres = huracanes[anio]
    nombres = list(nombres)
    donde   = nombres.index(nombre_huracan)
    cual  = indices_anio(huracanes,anio)
    desde = cual[0]
    hasta = cual[1]
    cantidad = M[3,desde+donde]
    return(cantidad)

# PROGRAMA ------------------------
import numpy as np

M = np.array([[20, 30, 19, 15, 18],
              [89,195,120,150,240],
              [65,165,100,110,200],
              [30, 49, 35, 89, 67],
              [ 5, 18,  1,  2,  5]]
             )
# 2015:('Ana','Kate'), # No usado para el ejemplo (CONFUSO)
huracanes = {2016:('Alex', 'Otto'),
             2017:('Ariene', 'Harvey','Irma'),
             }
cat = 2
anio = 2017
nombre_huracan = 'Harvey'

# PROCEDIMIENTO
categoria = categoriza(M)
marejadas = total_marejada(M,cat)
indices   = indices_anio(huracanes,anio)
vel_superior = velocidad_superior(M,huracanes,anio)
energia = ACE(M,huracanes,anio)
llovio  = lluvia(M, huracanes, nombre_huracan,anio)

# SALIDA
print(M)
print(huracanes)
print('---')
print('categorias: ', categoria)
print('Marejadas cat['+str(cat)+']: ', marejadas)
print('indices: ', indices)
print('velocidad superior: ', vel_superior)
print('Energia liberada: ',energia)
print('lluvia en mm: ', llovio)

Ejercicio: 3Eva_IT2016_T2 sensar cultivos con dron

Propuesta de solución en Python:

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IT2016_T2 sensar cultivos con dron
import numpy as np
import random as rnd

def  sensarCultivos(posicion):
    # Solo para generar una matriz que
    # permita trabajar con el programa
    valor = int(rnd.random()*10+1)
    return(valor)

def generarplantacion(dimension):
    n = dimension[0]
    m = dimension[1]
    plantacion = np.zeros(shape=(n,m),dtype=int)
    i = 0
    while not(i>=n):
        j = 0
        while not(j>=m):
            posicion = [i,j]
            valor = sensarCultivos(posicion)
            plantacion[i,j] = valor
            j = j + 1
        i = i + 1
    return(plantacion)

# usa matriz densidad de 1 y 0 para facilitar 
# el cálculo del literal c
def analizarDensidad(plantacion, limite):
    tamano = np.shape(plantacion)
    n = tamano[0]
    m = tamano[1]
    densidad  = np.zeros(shape=(n,m),dtype=int)
    resultado = []
    i = 0
    while not(i>=n):
        fila = []
        j = 0
        while not(j>=m):
            if (plantacion[i,j]>=limite):
                densidad[i,j]=1
                fila.append('ALTO')
            else:
                fila.append('Bajo')
            j = j + 1
        resultado.append(fila)
        i = i + 1
    
    return(densidad)

def reporteCrecimento(plantacion,densidad):
    tamano = np.shape(plantacion)
    n = tamano[0]
    m = tamano[1]
    casillas = n*m
    
    sumaALTO = 0
    sumaBAJO = 0
    i = 0
    while not(i>=n):
        j = 0
        while not(j>=m):
            valor = plantacion[i,j]
            if (densidad[i,j]==1):
                sumaALTO = sumaALTO + valor
            else:
                sumaBAJO = sumaBAJO + valor
            j = j + 1
        i = i + 1
    prmALTO  = sumaALTO/(np.sum(densidad))
    prmBAJO  = sumaBAJO/(n*m-np.sum(densidad))
    promedio = [prmALTO,prmBAJO]
    return(promedio)

crear un archivo de funciones para importar si las funciones se crean en otro archivo.

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
import dronescultivos as dron

# PROGRAMA
# INGRESO , usa datos aleatorios como prueba
dimension = (3,4)
plantacion = dron.generarplantacion(dimension)

#PROCEDIMIENTO
limite = 4
densidad = dron.analizarDensidad(plantacion, limite)
reporte  = dron.reporteCrecimento(plantacion,densidad)

#SALIDA
print(plantacion)
print(densidad)
print(reporte)

Ejercicio: 3Eva_IIT2016_T1 Facturar llamadas telefónicas

Propuesta de solución en Python, El ejercicio tiene tarea por completar.

Para las pruebas, requiere el archivo clientes01.csv en el mismo directorio del archivo.py

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IIT2016_T1 Facturar llamadas telefónicas
# se incluye la estructura de diccionarios.
# Tarea: Completar facturación y estadísticas

def obtenerClientes(nombreArchivo):
    facturar = {}

    archivo = open(nombreArchivo,'r')
    linea   = archivo.readline()
    while not(linea==''):
        linea  =linea.strip('\n')
        partes = linea.split(',')
        ced = partes[0]
        num = partes[1]
        sec = partes[2]
        parm = partes[3].split('|')
        nac = float(parm[0])
        ext = float(parm[1])
        est = partes[4]

        if not(ced in facturar):
            facturar[ced] = {num:{
                             'sector': sec,
                             'nacional': nac,
                             'internac': ext,
                             'estado': est }}
        else: 
            facturar[ced][num] = {
                             'sector': sec,
                             'nacional': nac,
                             'internac': ext,
                             'estado': est }
        
        linea = archivo.readline()
    archivo.close()
    
    return(facturar)

def generarFactura(tabla):
    # Lista de clientes
    cedulas = tabla.keys()
    cedulas = list(cedulas)
    n = len(cedulas)

    # Mostrar cada cliente
    i = 0
    while not(i>=n):
        # Para pantalla
        # print(cedulas[i])
        
        # Cada archivo
        narchivo = cedulas[i] + '.txt'
        archivo = open(narchivo, 'w')
        archivo.write('Empresa Telefonica de Guayaquil \n')
        archivo.write('cliente: ' + cedulas[i] + '\n')
        archivo.write('Detalle Deuda: \n')

        tablanumeros = tabla[cedulas[i]]
        # print(tablanumeros)
        
        numeros = tablanumeros.keys()
        numeros = list(numeros)
        # print(numeros)

        m = len(numeros)
        j = 0
        while not(j>=m):
            datos = tablanumeros[numeros[j]]
            nac = tablanumeros[numeros[j]]['nacional']
            costonac = nac * 0.03
            archivo.write(numeros[j] + ' nac: '+str(costonac)+ '\n')
            j = j + 1
        
        archivo.close()
        
        i = i + 1
    return()

# PROGRAMA
# INGRESO
narchivo = 'clientes.csv'

# PROCEDIMIENTO
tabla = obtenerClientes(narchivo)

# SALIDA
generarFactura(tabla)

# -------
# Usado para explicación de uso de diccionarios
### Lista de clientes
##cedulas = tabla.keys()
##cedulas = list(cedulas)
##n = len(cedulas)
##
### Salida
##print('los clientes son: ', cedulas)
##print('los datos del cliente son:')
##for i in range(0,n,1):
##    print(cedulas[i])
##    numeroscedula = tabla[cedulas[i]].keys()
##    print(numeroscedula)

Ejercicio: 3Eva_IIT2016_T2 Juntas receptoras de voto

Archivos para prueba:

JRV_Harchivo.txt
JRV_Marchivo.txt
JRV_Candidatosarchivo.txt

Propuesta de solución en Python:

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IIT2016_T2 Juntas receptoras de voto
import numpy as np

def contarVotos(JRV_H, JRV_M):
    cuenta_H = np.sum(JRV_H, axis=0)

    # Suma columnas
    tamano = np.shape(JRV_M)
    nvotantes   = tamano[0]
    ncandidatos = tamano[1]
    cuenta_M = np.zeros(ncandidatos, dtype=int)
    
    for columna in range(0,ncandidatos,1):
        fila = 0 # cambiar a for
        while not(fila>=nvotantes):
            cuenta_M[columna] = cuenta_M[columna] + JRV_M[fila, columna]
            fila=fila+1
            
    conteo = cuenta_H + cuenta_M
    conteo = tuple(conteo)
    return(conteo)

def segundaVuelta(JRV_H, JRV_M):
    respuesta = 0
    conteo  = contarVotos(JRV_H, JRV_M)
    conteo  = np.array(conteo)
    total   = np.sum(conteo)
    primero = np.argmax(conteo)
    votos1  = conteo[primero]
    conteo[primero] = 0
    segundo = np.argmax(conteo)
    votos2  = conteo[segundo]
    
    limite40 = 0.4*total
    limite10 = 0.1*total
    if (votos1<=limite40):
        diferencia = votos1-votos2
        if (diferencia<=limite10):
            respuesta = 1
    
    return(respuesta)

def estadistica(JRV_H, JRV_M, candidatos, nombre):
    conteo = contarVotos(JRV_H, JRV_M)
    conteo = np.array(conteo)
    
    #Buscar posicion nombre del candidato
    donde = -1
    n = len(candidatos)
    i = 0
    while not(i>=n or donde>=0):
        if (nombre == candidatos[i]):
            donde = i
        i = i + 1
    votos = conteo[donde]
    
    # Votos hombres y mujeres
    cuenta_H = np.sum(JRV_H, axis=0)
    votos_H  = cuenta_H[donde]
    votos_M  = votos - votos_H

    respuesta = [nombre, votos_H, votos_M]
    return(respuesta)

# PROGRAMA ---------------------------
# INGRESO
nJRV_H = 'JRV_Harchivo.txt'
nJRV_M = 'JRV_Marchivo.txt'
ncandidatos = 'JRV_Candidatosarchivo.txt'

# PROCEDIMIENTO
# Lectura de datos desde archivos
JRV_H = np.loadtxt(nJRV_H)
JRV_M = np.loadtxt(nJRV_M)

candidatos = []
archivo = open(ncandidatos,'r')
linea = archivo.readline()
linea = linea.strip('\n')
while not(linea==''):
    candidatos.append(linea)
    linea = archivo.readline()
    linea = linea.strip('\n')
archivo.close()

# Conteo de votos y revisión de 2da Vuelta
conteo    = contarVotos(JRV_H, JRV_M)
revisa2da = segundaVuelta(JRV_H, JRV_M)

# Estadísticas para todos los candidatos
tabla = {}
k = len(candidatos)
j=0
while not(j>=k):
    nombre = candidatos[j]
    revisaest = estadistica(JRV_H, JRV_M, candidatos, nombre)
    H = revisaest[1]
    M = revisaest[2]
    tabla[nombre] = {'conteo_H': H,
                     'conteo_M': M}
    j = j + 1

# SALIDA
print('Tabla:  JRV_H')
print(JRV_H)
print('Tabla:  JRV_M')
print(JRV_M)
print('Lista:  candidatos ')
print(candidatos)
print('Conteo de votos:')
print(conteo)
print('Hay segunda vuelta: ', revisa2da)
print('Revisión estadística: ')
print(tabla)