Ejercicio: 2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar

Se añade las instrucciones al tema anterior,

Se incluyen las funciones que se asume como existentes para prueba de programa. En caso de problemas o dudas con el conteo, elaborar una función contar.

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar
import numpy as np

# ----- NUMERAL 2 ----- 
# Funciones que suponen que existen:
def cuadrantes(matriz):
    tamano = np.shape(matriz)
    n = tamano[0]
    m = tamano[1]
    mitadfila = n//2
    mitadcolumna = m//2
    Q1 = matriz[0:mitadfila,0:mitadcolumna]
    Q2 = matriz[0:mitadfila,mitadcolumna:]
    Q3 = matriz[mitadfila:,0:mitadcolumna]
    Q4 = matriz[mitadfila:,mitadcolumna:]
    Q = np.array([Q1,Q2,Q3,Q4])
    return(Q)

def poblacionEspecie(mAnimales, especie):
    Q = cuadrantes(mAnimales)
    # pQ1 = np.count_nonzero(Q[0],especie)
    # np.count_nonzero no hay en funciones referencia
    # no en cheatsheet “Cheat Sheet”
    # se procede con algoritmo básico
    k = len(Q)
    poblacion = np.zeros(k,dtype=int)
    for i in range(0,k,1):
        unaQ = Q[i]
        tamano = np.shape(unaQ)
        n = tamano[0]
        m = tamano[1]
        for f in range(0,n,1):
            for c in range(0,m,1):
                if (unaQ[f,c] == especie):
                    poblacion[i] = poblacion[i] +1
    return(poblacion)

# otra forma es usar una funcion contar en arreglo
def contarenarreglo(arreglo,cual):
    tamano = np.shape(arreglo)
    n = tamano[0]
    m = tamano[1]
    contar = 0
    for f in range(0,n,1):
        for c in range(0,m,1):
            if (arreglo[f,c] == cual):
                contar = contar+1
    return(contar)

Desarrollo del numeral 2:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar
import numpy as np

# funcion numeral 2
def densidadHielo(mHielo):
    Q = cuadrantes(mHielo)
    k = len(Q)
    densidad = np.zeros(k,dtype=float)
    for i in range(0,k,1):
        unaQ = Q[i]
        tamano = np.shape(unaQ)
        n = tamano[0]
        m = tamano[1]
        densidad[i]=np.sum(unaQ)/(n*m)
    return(densidad)

desarrollo del numeral 3:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar
import numpy as np

# ----- NUMERAL 3 -----
def especieDominante(mAnimales):
    especies = np.unique(mAnimales)
    ke = len(especies)
    
    Q = cuadrantes(mAnimales)
    k = len(Q)
    dominante = np.zeros(k,dtype=int)
    for i in range(0,k,1):
        unaQ = Q[i]
        cuantos = np.zeros(ke,dtype=int)
        for j in range(0,ke,1):
            # solución semejante al NUMERAL 2
            # para poblacionEspecie
            animal = especies[j]
            cuantos[j] = contarenarreglo(unaQ,animal)
        mayoria = np.argmax(cuantos)
        dominante[i]= especies[mayoria]
    return(dominante)

desarrollo del numeral 4

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar
import numpy as np

# ----- NUMERAL 4 -----
def migracionEspecie(mAnimales2009, mAnimales2019, especie):
    Q = cuadrantes(mAnimales2009)
    k = len(Q)
    cuantos = np.zeros(k,dtype=int)
    for i in range(0,k,1):
        unaQ = Q[i]
        cuantos[i] = contarenarreglo(unaQ,especie)
    mayoria09 = np.argmax(cuantos)

    Q = cuadrantes(mAnimales2019)
    k = len(Q)
    cuantos = np.zeros(k,dtype=int)
    for i in range(0,k,1):
        unaQ = Q[i]
        cuantos[i] = contarenarreglo(unaQ,especie)
    mayoria19 = np.argmax(cuantos)
    
    # considere numeración desde 0
    a = 'Q'+str(mayoria09+1)
    b = 'Q'+str(mayoria19+1)
    migraron =[a,b]
    return(migraron)

Programa de prueba, incluye las partes del tema anterior

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar
import numpy as np

# PROGRAMA DE PRUEBA
# INGRESO
narchivo = 'artico2009-2019.txt'
especie = 4

# PROCEDIMIENTO

# ----- NUMERAL 1 ----- 
matrices = crearMatriz(narchivo)
mhielo09 = matrices[0]
mhielo19 = matrices[1]
manimales09 = matrices[2]
manimales19 = matrices[3]

# ----- NUMERAL 2 ----- 
Q = cuadrantes(manimales09)
poblacion = poblacionEspecie(manimales09, especie)
densidad = densidadHielo(mhielo09)

# ----- NUMERAL 3 -----
dominante = especieDominante(manimales09)

# ----- NUMERAL 4 -----
migraron = migracionEspecie(manimales09, manimales19, especie)


# SALIDA
print(' ----- NUMERAL 1 ----- ')
print('hielo 2009')
print(mhielo09)
print('hielo 2019')
print(mhielo19)
print('animales 2009')
print(manimales09)
print('animales 2019')
print(manimales19)

print(' ----- NUMERAL 2 ----- ')
print('cuadrantes de manimales09')
print(Q)
print('población por cuadrantes de manimales09')
print('para especie = 4')
print(poblacion)
print('densidad de hielo para mhielo09')
print(densidad)

print(' ----- NUMERAL 3 ----- ')
print('dominantes en manimales09')
print(dominante)
print(' ----- NUMERAL 4 ----- ')
print('migraron de la especie: ',especie)
print(migraron)

Los resultados obtenidos son:

animales 2009
[[ 1  2  4  4]
 [ 2  5  5  3]
 [ 1  3  9  1]
 [ 1  1  4  2]
 [ 4 22  4  7]
 [ 1  1  4  0]]

 ----- NUMERAL 2 ----- 
cuadrantes de manimales09
[[[ 1  2]
  [ 2  5]
  [ 1  3]]

 [[ 4  4]
  [ 5  3]
  [ 9  1]]

 [[ 1  1]
  [ 4 22]
  [ 1  1]]

 [[ 4  2]
  [ 4  7]
  [ 4  0]]]
población por cuadrantes de manimales09
para especie = 4
[0 2 1 3]
densidad de hielo para mhielo09
[0.5        0.66666667 0.83333333 0.5       ]
 ----- NUMERAL 3 ----- 
dominantes en manimales09
[1 4 1 4]
 ----- NUMERAL 4 ----- 
migraron de la especie:  4
['Q4', 'Q2']

Ejercicio: 2Eva_IIT2018_T1 Hielo y especies en Ártico-Archivo

Usando el archivo proporcionado en el ejemplo: 'artico2009-2019.txt'

se crea la función y programa de prueba con las instrucciones más básicas y simples:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T1 Hielo y especies en Ártico-Archivo

# ----- NUMERAL 1 ----- 
def crearMatriz(narchivo):
    archivo = open(narchivo,'r')
    
    # dimensiones de matriz
    linea = archivo.readline()
    n = int(linea.strip('\n'))
    linea = archivo.readline()
    m = int(linea.strip('\n'))
    # se crean las matrices
    mhielo09 = np.zeros(shape=(n,m),dtype=int)
    mhielo19 = np.zeros(shape=(n,m),dtype=int)
    manimales09 = np.zeros(shape=(n,m),dtype=int)
    manimales19 = np.zeros(shape=(n,m),dtype=int)
    
    # linea encabezados, No procesada
    linea = archivo.readline()
    
    # linea datos
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        anio    =  partes[0]
        fila    = int(partes[1])
        columna = int(partes[2])
        hielo   = int(partes[3])
        animal  = int(partes[4])
        if (anio =='2009'):
            mhielo09[fila,columna] = hielo
            manimales09[fila,columna] = animal
        if (anio =='2019'):
            mhielo19[fila,columna] = hielo
            manimales19[fila,columna] = animal
        linea = archivo.readline()
    archivo.close()
    matrices = [mhielo09,
                mhielo19,
                manimales09,
                manimales19]
    return(matrices)

# PROGRAMA DE PRUEBA
# INGRESO
narchivo = 'artico2009-2019.txt'

# PROCEDIMIENTO
# ----- NUMERAL 1 ----- 
matrices = crearMatriz(narchivo)
mhielo09 = matrices[0]
mhielo19 = matrices[1]
manimales09 = matrices[2]
manimales19 = matrices[3]

# SALIDA
print(' ----- NUMERAL 1 ----- ')
print('hielo 2009')
print(mhielo09)
print('hielo 2019')
print(mhielo19)
print('animales 2009')
print(manimales09)
print('animales 2019')
print(manimales19)

para obtener:

 ----- NUMERAL 1 ----- 
hielo 2009
[[1 0 0 1]
 [0 1 1 1]
 [1 0 1 0]
 [1 1 1 0]
 [0 1 0 1]
 [1 1 1 0]]
hielo 2019
[[1 0 0 1]
 [0 1 0 1]
 [1 0 1 0]
 [1 0 1 0]
 [0 1 0 1]
 [0 0 1 0]]
animales 2009
[[ 1  2  4  4]
 [ 2  5  5  3]
 [ 1  3  9  1]
 [ 1  1  4  2]
 [ 4 22  4  7]
 [ 1  1  4  0]]
animales 2019
[[ 3  2  4  1]
 [ 0 11  3  5]
 [ 1  0 67  1]
 [ 2 22  3  2]
 [13 13  2  3]
 [ 3  0  1  0]]

Ejercicio: 1Eva_IIT2018_T3 Compras 'Black Friday'

Los numerales se desarrollan como funciones, dividiendo el ejercicio por partes.

El bloque de procedimiento debe hacer el llamado a las funciones para encontrar las respuestas.

Algoritmo en Python

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2018_T3 Compras ‘Black Friday’
# Tarea: descuentosPorSección
import random as rnd
import numpy as np

def calcularPrecio(unacompra,Codigo,Precio,Descuento):
    unprecio = 0
    if (unacompra in Codigo):
        donde = Codigo.index(unacompra)
        valor = Precio[donde]
        unprecio = valor - Descuento[donde]*valor/100
    return(unprecio)

def calcularTotal(compras,Codigo,Precio,Descuento):
    m = len(compras)
    totalpagar = 0
    i = 0
    while not(i>=m):
        unacompra = compras[i]
        unprecio = calcularPrecio(unacompra, Codigo,
                                  Precio, Descuento)
        totalpagar = totalpagar + unprecio
        i = i + 1
    return(totalpagar)

def hallarSecciones(compras,Codigo,Seccion):
    m = len(compras)
    visitar = []
    i = 0
    while not(i>=m):
        unacompra = compras[i]
        donde = Codigo.index(unacompra)
        unaseccion = Seccion[donde]
        if not(unaseccion in visitar):
            visitar.append(unaseccion)
        i = i + 1
    return(visitar)

def descuentosPorSección(Descuento,Seccion):
    remate = []
    # Tarea: Desarrollar
    return(remate)
    
# INGRESO
unacompra = input('codigo de una compra: ')

# Tarea: ingresar varias compras
compras = ['SKU-5675', 'PSS-4542']
Codigo  = ['CTR-2424', 'SKU-5675', 'PSS-4542']
Precio  = [ 56.65, 32.00, 22.22]
Descuento = [0, 50, 10]
Seccion = ['Ropa Niños', 'Juguetes', 'Hombre']

# PROCEDIMIENTO
unprecio   = calcularPrecio(unacompra, Codigo,
                            Precio,Descuento)
totalpagar = calcularTotal(compras, Codigo,
                           Precio,Descuento)
visitar = hallarSecciones(compras,Codigo, Seccion)
remate  = descuentosPorSección(Descuento, Seccion)

# SALIDA
print('El precio de : ',unacompra)
print(unprecio)
print('total a pagar de lista de compras: ', totalpagar)
print('tiendas a visitar: ',visitar)
print('remate de productos por seccion: ',remate)

resultado del algoritmo

codigo de una compra: CTR-2424
El precio de :  CTR-2424
56.65
total a pagar de lista de compras:  35.998
tiendas a visitar:  ['Juguetes', 'Hombre']
remate de productos por seccion:  []
>>> 

Ejercicio: 1Eva_IIT2018_T2 Juego conocimiento (Ahorcado)

Propuesta de solución al ejercicio.

Estado del juego:  F***
 adivine una letra: C
 Adivinaste...C

Estado del juego:  FC**
turno: 1
fallas:  0
 adivine una letra: M
 Adivinaste...M

Estado del juego:  FC*M
turno: 2
fallas:  0
 adivine una letra: A
 NO es una letra de palabra...

Estado del juego:  FC*M
turno: 3
fallas:  1
 adivine una letra: N
 Adivinaste...N

Estado del juego:  FCNM
turno: 4
fallas:  1
Felicitaciones, adivinó: FCNM
>>> 

Algoritmo en Python

Siguiendo las sugerencias, para dividir y simplificar el problema, primero se crean las funciones: escondeletras(secreta) y cambialetra(secreta,letra,estado).

Se inicia con la selección aleatoria de la palabra secreta y el sorteo de la letra pista, verificando que sea consonante.

Se actualiza la palabra secreta con la letra pista, y se inicia el juego.

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2018_T2 Juego conocimiento (Ahorcado)
# propuesta de solución: edelros@espol.edu.ec
# tarea: indiferente usar mayúsculas/minúsculas
#        contar solo letras adivinadas, no repetidas

import numpy as np
import random as rnd

def escondeletras(secreta):
    estado = ''
    n = len(secreta)
    i = 0
    while not(i>=n):
        estado = estado + '*'
        i = i + 1 
    return(estado)

def cambialetra(secreta,letra,estado):
    nuevoestado = ''
    n = len(secreta)
    i = 0
    while not(i>=n):
        if (secreta[i]==letra):
            nuevoestado = nuevoestado + letra
        else:
            nuevoestado = nuevoestado + estado[i]
        i = i + 1
    return(nuevoestado)

# PROGRAMA JUEGO
# selecciona secreta
palabras = ['ESPOL','FCNM','FIEC','FIMCP','FICT']
n = len(palabras)
sorteo  = int(rnd.random()*n)+0
secreta = palabras[sorteo]

# estado inicial del juego
estado = escondeletras(secreta)

# una letra como pista
consonante = 'BCDFGHJKLMNPQRSTVWXYZ'
m = len(secreta)
sorteo = int(rnd.random()*m)+0
pista = secreta[sorteo]
while not(pista in consonante):
    sorteo = int(rnd.random()*m)+0
    pista  = secreta[sorteo]
    
# actualiza estado del juego
estado = cambialetra(secreta,pista,estado)

# Control del Juego
turnomax = 2*m
gana  = 1
falla = 0
print('Estado del juego: ', estado)

turno = 1
while not(turno>turnomax or gana==m):
    letra = input(' adivine una letra: ')
    if (letra in secreta):
        gana    =  gana +1
        estado  = cambialetra(secreta,letra, estado)
        mensaje = ' Adivinaste...' + letra
    else:
        falla   = falla + 1
        mensaje = ' NO es una letra de palabra...'
    
    print(mensaje)
    print()
    print('Estado del juego: ', estado)
    print('turno:', turno)
    print('fallas: ', falla)
    turno = turno + 1

if (turno<=turnomax and gana==m):
    mensaje = 'Felicitaciones, adivinó: ' + secreta
else:
    mensaje = 'lo lamento, perdió..., la palabra era: '
    mensaje = mensaje + secreta

# SALIDA
print(mensaje)

Recuerde que se ha dejado como tarea, realizar las instrucciones para cumplir que:
- sea indiferente usar mayúsculas/minúsculas
- contar solo letras adivinadas, no repetidas

Referencia: 2Eva_IT2005_T3 Adivina palabra (ahorcado)

Solución propuesta: s2Eva_IT2005_T3 Adivina palabra (ahorcado)