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

Algoritmo en Python

# 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:

Algoritmo 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

Algoritmo 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

Algoritmo en Python

# 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

Algoritmo en Python

# 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

Algoritmo en Python

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)