Categoría: Solución 3ra Evaluación

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)

Ejercicio: 3Eva_IIT2015_T3 funciones matrices rotar, extraer

Propuesta de solución en Python

Tarea: Integrar con tema 4

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IIT2015_T3 funciones matrices rotar, extraer
# propuesta: edelros@espol.edu.ec
# version con lazos y condicionales. 
# tarea: simplificar lazos con 'for'

import numpy as np

# Tema 3 a)
def rotando(matriz,k):

    #cuenta rotaciones
    cuenta = 0    
    while not(cuenta>=k):
        n,m = matriz.shape 
        tabla = numpy.zeros(shape=(m,n),dtype=int)

        # inicia rotación
        i = 0 
        while not(i>=n):
            j = 0
            while not(j>=m):
                f = j
                c = (n-1)-i
                tabla[f,c] = matriz[i,j]
                j = j + 1
            i = i + 1
        
        matriz = np.copy(tabla)
        cuenta = cuenta + 1
    return(matriz)

# Tema 3 b) funcion para extraer una esquina 
# de tamaño t de una matriz
# k=0 ;esquina superior izquierda 
# k=1 ;esquina superior derecha
# k=3 ;esquina inferior izquierda 
# k=2 ;esquina inferior derecha

def extraeresquina(matriz,k,t):
    n,m = matriz.shape
    esquina = np.zeros(shape=(t,t), dtype=int)
    i = 0
    while not(i>=t):
        j = 0
        while not(j>=t):
            if (k==0):
                f = i
                c = j
            if (k==1):
                f = i
                c = (m-t)+j
            if (k==2):
                f = (n-t)+i
                c = (m-t)+j
            if (k==3):
                f = (n-t)+i
                c = j
            esquina[i,j]=matriz[f,c]
            j = j+1
        i = i+1   
    return(esquina)

Ejercicio: 3Eva_IIT2015_T4 Orientar código QR (Quick Response Code)

Propuesta de solución en Python para 3ra Eva. II Término 2015 Tema 3 y 4.

Los archivos para probar el algoritmo son:

codigoQR.txt

referenciaQR.txt

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IIT2015_T3 funciones matrices rotar, extraer
# propuesta: edelros@espol.edu.ec
# version con lazos y condicionales. 
# tarea: simplificar lazos con 'for'

import numpy as np

# Tema 3 a)
def rotando(matriz,k):

    #cuenta rotaciones
    cuenta = 0    
    while not(cuenta>=k):
        n,m = matriz.shape 
        tabla = numpy.zeros(shape=(m,n),dtype=int)

        # inicia rotación
        i = 0 
        while not(i>=n):
            j = 0
            while not(j>=m):
                f = j
                c = (n-1)-i
                tabla[f,c] = matriz[i,j]
                j = j + 1
            i = i + 1
        
        matriz = np.copy(tabla)
        cuenta = cuenta + 1
    return(matriz)

# Tema 3 b) funcion para extraer una esquina 
# de tamaño t de una matriz
# k=0 ;esquina superior izquierda 
# k=1 ;esquina superior derecha
# k=3 ;esquina inferior izquierda 
# k=2 ;esquina inferior derecha

def extraeresquina(matriz,k,t):
    n,m = matriz.shape
    esquina = np.zeros(shape=(t,t), dtype=int)
    i = 0
    while not(i>=t):
        j = 0
        while not(j>=t):
            if (k==0):
                f = i
                c = j
            if (k==1):
                f = i
                c = (m-t)+j
            if (k==2):
                f = (n-t)+i
                c = (m-t)+j
            if (k==3):
                f = (n-t)+i
                c = j
            esquina[i,j]=matriz[f,c]
            j = j+1
        i = i+1   
    return(esquina)

# Tema 4 ------------------------------

# Programa para orientar el codigo QR

# INGRESO por lectura desde un archivo
codigo     = np.loadtxt('codigo.txt',dtype=int)
referencia = np.loadtxt('referencia.txt',dtype=int)

# PROCEDIMIENTO

# comparando código y esquinas de referencia
# resultados por esquina
t,r = referencia.shape
compara = np.zeros(4, dtype=int) 

#compara esquinas
k = 0  
while not(k>=4):
    esquina    = extraeresquina(codigo,k,t)
    esqgirada  = rotando(referencia,k)
    compara[k] = np.array_equal(esquina,esqgirada)
    k = k + 1
    
# Selecciona la rotacion
if (compara[0]==1 and compara[1]==1
    and compara[2]==0 and compara[3]==1):
    orientado = rotando(codigo,0)
    
if (compara[0]==1 and compara[1]==0
    and compara[2]==1 and compara[3]==1):
    orientado = rotando(codigo,1)
    
if (compara[0]==0 and compara[1]==1
    and compara[2]==1 and compara[3]==1):
    orientado = rotando(codigo,2)
    
if (compara[0]==1 and compara[1]==1
    and compara[2]==1 and compara[3]==0):
    orientado = rotando(codigo,3)

# SALIDA
print(orientado)

Ejercicio: 3Eva_IIT2015_T2 Gestionar mensajes con etiquetas

Propuesta de solución en Python 3ra Eva. II Término 2015 Tema 1 y 2

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IIT2015_T2 Gestionar mensajes con etiquetas
# propuesta: edelros@espol.edu.ec
# version con lazos y condicionales.
# tarea: simplificar con 'for'

import numpy as np

# Tema 1. literal a)
def buscaetiqueta(mensaje):
    n = len(mensaje)
    etiquetas = []
    copia = 0
    
    i = 0
    while not(i>=n):

        #Inicia copia etiqueta
        if (mensaje[i]=='#'): 
            copia = 1
            encontre = ''
        
        if (copia==1):
            encontre = encontre + mensaje[i]
            if (i<(n-1)):
                if (mensaje[i+1]==' ' or mensaje[i+1]==','):
                    copia = 0
                    etiquetas.append(encontre)
            if (i==(n-1)):
                etiquetas.append(encontre)
        i = i + 1
    return(etiquetas)

# Tema 1. literal b)
def tabulando(lista):
    n = len(lista) # usando listas
    repetido = np.zeros(n,dtype=int)
    numrepetido = 0

    # Marcando repetidos
    i = 0 
    while not(i>=(n-1)):
        j = i + 1
        while not(j>=n):
            if (lista[i]==lista[j]):
                repetido[j]=1
                numrepetido=numrepetido+1
            j = j + 1
        i = i + 1

    #copia vector unicos, tabula usando arreglo
    unicos = []
    i = 0
    while not(i>=n):
        if (repetido[i]==0):
            unicos.append([lista[i],0])
        i = i + 1
    k = len(unicos)

    # Cuenta y Acumula
    i = 0
    while not(i>=n):
        
        #busca posicion en unicos
        j = 0     
        while not(j>=k):
            if (lista[i]==unicos[j][0]):
                unicos[j][1] = unicos[j][1]+1
            j = j + 1
            
        i = i + 1
        
    return(unicos)

# Tema 2. Admnistra mensajes de una red social
usuario = []
mensaje = []

opcion = 0
while not(opcion==4):
    print('1. Ingresar mensaje')
    print('2. Usuario frecuente')
    print('3. Tendencias')
    print('4. Salir')

    opcion = int(input('cual opcion: '))

    if (opcion==1):
        print('1. Ingresar mensaje')
        quien = input('nombre usuario: ')
        dice  = input('mensaje: ')
        usuario.append(quien)
        mensaje.append(dice)

    if (opcion==2):
        print('2. Usuario frecuente')
        quienes = tabulando(usuario)
        n = len(quienes)
        mayor = 0
        k = 1
        while not (k>=n):
            if (quienes[k][1]>quienes[mayor][1]):
                mayor = k
            k = k + 1
        print('los usuarios:')
        print(quienes)
        print('el usuario mas frecuente es: ',
                quienes[mayor][0])

    if (opcion==3):
        print('3. Tendencias')
        n = len(mensaje)
        todaetiqueta = []
        i = 0
        while not(i>=n):
            cuales = buscaetiqueta(mensaje[i])
            m = len(cuales)
            if (m>0):
                j = 0 #añade cada etiqueta
                while not(j>=m):
                    todaetiqueta.append(cuales[j])
                    j = j+1
            i = i + 1
        etiquetas = tabulando(todaetiqueta)
        n = len(etiquetas)
        mayor = 0
        k = 1
        while not (k>=n):
            if (etiquetas[k][1]>etiquetas[mayor][1]):
                mayor = k
            k = k + 1
        print(etiquetas)
        print('La tendencia es: ',etiquetas[mayor][0])

    if (opcion==4):
        print('Gracias por usar el software')

Ejercicio: 3Eva_IIT2015_T1 Mensajes en redes sociales y etiquetas

Propuesta de solución en Python 3ra Eva. II Término 2015 Tema 1

Tarea: Integrar con Tema 2

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IIT2015_T1 Mensajes en redes sociales y etiquetas
# propuesta: edelros@espol.edu.ec
# version con lazos y condicionales.
# tarea: simplificar con 'for'

import numpy as np

# Tema 1. literal a)
def buscaetiqueta(mensaje):
    n = len(mensaje)
    etiquetas = []
    copia = 0
    
    i = 0
    while not(i>=n):

        #Inicia copia etiqueta
        if (mensaje[i]=='#'): 
            copia = 1
            encontre = ''
        
        if (copia==1):
            encontre = encontre + mensaje[i]
            if (i<(n-1)):
                if (mensaje[i+1]==' ' or mensaje[i+1]==','):
                    copia = 0
                    etiquetas.append(encontre)
            if (i==(n-1)):
                etiquetas.append(encontre)
        i = i + 1
    return(etiquetas)

# Tema 1. literal b)
def tabulando(lista):
    n = len(lista) # usando listas
    repetido = np.zeros(n,dtype=int)
    numrepetido = 0

    # Marcando repetidos
    i = 0 
    while not(i>=(n-1)):
        j = i + 1
        while not(j>=n):
            if (lista[i]==lista[j]):
                repetido[j]=1
                numrepetido=numrepetido+1
            j = j + 1
        i = i + 1

    #copia vector unicos, tabula usando arreglo
    unicos = []
    i = 0
    while not(i>=n):
        if (repetido[i]==0):
            unicos.append([lista[i],0])
        i = i + 1
    k = len(unicos)

    # Cuenta y Acumula
    i = 0
    while not(i>=n):
        
        #busca posicion en unicos
        j = 0     
        while not(j>=k):
            if (lista[i]==unicos[j][0]):
                unicos[j][1] = unicos[j][1]+1
            j = j + 1
            
        i = i + 1
        
    return(unicos)