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: 2Eva_IIT2016_T1 Multas de Transito por sector

Propuesta de solución en Python:

# CCPG1001-Fundamentos de programación
# 2Eva_IIT2016_T1 Multas de Transito por sector
import numpy as np

def generaMatriz(listamultas,sectores):
    n = len(sectores)
    unafila = sectores[0]
    
    m = len(unafila)
    matriz = np.zeros(shape=(n,m),dtype=float)

    k = len(listamultas)
    i = 0
    while not(i>=k):
        f = listamultas[i][0]
        c = listamultas[i][1]
        valor = listamultas[i][2]
        matriz[f,c] = matriz[f,c] + valor
        i = i+1
    return(matriz)

def sectorTop(matriz):
    
    # TAREA: Realizar para este y oeste
    tamano = np.shape(matriz)
    n = tamano[0]
    m = tamano[1]
    norte = matriz[0,:]
    sur = matriz[n-1,:]
    centro = matriz[1:3,2]

    rnorte  = np.sum(norte)
    rsur    = np.sum(sur)
    rcentro = np.sum(centro)
    
    suma = [rnorte,rsur,rcentro]
    referencia = ['norte','sur','centro']
    
    cual   = np.argmax(suma)
    nombre = referencia[cual]
    valor  = suma[cual]
    respuesta = [nombre,valor]

    return(respuesta)


# PROGRAMA
# INGRESO
sectores = [
    ['Norte','Norte','Norte','Norte','Norte'],
    ['Oeste','Oeste','Centro','Este','Este'],
    ['Oeste','Oeste','Centro','Este','Este'],
    ['Oeste','Oeste','Centro','Este','Este'],
    ['Sur','Sur','Sur','Sur','Sur']]

listamultas = [(0, 0, 120),
               (1, 2, 330),
               (3, 4, 123),
               (4, 2, 62),
               (0, 0, 50),
               (4, 4, 89),
               (0, 3, 25),
               (2, 0, 43),
               (3, 2, 21),
               (0, 0, 120)]

# PROCEDIMIENTO
recaudar = generaMatriz(listamultas,sectores)

# SALIDA
print(sectores)
print(listamultas)
print('Hay que recaudar:')
print(recaudar)

Resultado del algoritmo

[['Norte', 'Norte', 'Norte', 'Norte', 'Norte'], 
['Oeste', 'Oeste', 'Centro', 'Este', 'Este'], 
['Oeste', 'Oeste', 'Centro', 'Este', 'Este'], 
['Oeste', 'Oeste', 'Centro', 'Este', 'Este'], 
['Sur', 'Sur', 'Sur', 'Sur', 'Sur']]
[(0, 0, 120), (1, 2, 330), (3, 4, 123), 
(4, 2, 62), (0, 0, 50), (4, 4, 89), 
(0, 3, 25), (2, 0, 43), (3, 2, 21), (0, 0, 120)]
Hay que recaudar:
[[290.   0.   0.  25.   0.]
 [  0.   0. 330.   0.   0.]
 [ 43.   0.   0.   0.   0.]
 [  0.   0.  21.   0. 123.]
 [  0.   0.  62.   0.  89.]]
>>> 

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: 2Eva_IIT2015_T4 biciespol, prestamos de bicicletas

Algoritmo en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2015_T4 biciespol, prestamos de bicicletas
# Tarea: validar matricula de estudiante

opcion = -1 # aun no es escoge una opcion
while not(opcion==6):
    # Presenta el menú
    print('Menú:')
    print('1. Formulario de Préstamos')
    print('2. Registro de bicicletas')
    print('3. Préstamo')
    print('4. Devolución')
    print('5. Inventario de estado')
    print('6. Salir')
    
    opcion = int(input('cual es su opcion:'))
    
    if opcion==1:
        # Ingresa un estudiante
        mat  = input('matricula: ')
        nom  = input('nombre: ')
        carr = input('carrera: ')
        unestudiante = [mat,nom,carr]
        formulario.append(unestudiante)

    if opcion==2:    
        # Bicicletas
        m =  int(input('cuantas bicicletas:'))
        bicicletas =[]
        j = 0
        while not(j>=m):
            cod = input('codigo: ')
            est = 0 # iniciar con cero
            ubi = int(input('ubicacion:'))
            # crea un registro
            unabici = [cod,est,ubi]
            # Añade a la tabla
            bicicletas.append(unabici)
            j = j+1

    if opcion==3:
        
        est = input('matricula')
        cod = input('codigo: ')
        ubi = int(input('ubicacion'))

        # Tarea: validar matricula de estudiante

        # busca la bicicleta
        m = len(bicicletas)
        j = 0
        while not(j>=m):
            if bicicletas[j][0]==cod:
                donde = j
            j = j + 1
        
        # prestamo
        if (bicicletas[donde][1] == '0' and bicicletas[donde][2]==ubi):
            bicicletas[donde][1] = est
            bicicletas[donde][2] = 0
            
    # Opciones 4 y 5 continuan en el siguiente laboratorio
    
    if opcion==6:
        print('gracias por usar el software...')
        print('@espol.edu.ec')

Ejercicio: 2Eva_IIT2015_T2 funcion totalportipo(tabla)

Solución propuesta en Python, continúa junto al tema 3.

Algoritmo en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2015_T2 funcion totalportipo(tabla)
# propuesta de repaso: edelros@espol.edu.ec

import numpy as np

def totalportipo(tabla):
    # Tamaño de tabla con codigoplaya,recolectado
    n,k = tabla.shape  
    
    # verifica banderas repetido cambiando a 1
    repetidos = np.zeros(n,dtype=int)
    i = 0
    while not(i>=(n-1)):
        j = i + 1
        while not(j>=n):
            if (tabla[i,0]==tabla[j,0]):
                repetidos[j] = 1
            j = j+1
        i = i + 1
    
    # cuenta los que se eliminan
    # para ver los m que son únicos
    eliminar = 0
    fila = 0
    while not(fila>=n):
        eliminar = eliminar + repetidos[fila]
        fila = fila + 1
    m = n-eliminar

    # copiar codigos unicos en tabulado columna 0
    tabulado = np.zeros(shape=(m,3), dtype=float)
    fila = 0
    j = 0
    while not(fila>=n):
        if (repetidos[fila]==0):
            tabulado[j,0] = tabla[fila,0]
            j = j + 1
        fila = fila + 1

    # Cuenta voluntarios por playa en tabulado columna 1
    # Acumula recolectado por playa en tabulado columna 2
    fila = 0
    while not(fila>=n):
        cual = tabla[fila,0]
        # encuentra el índice en donde
        donde = np.where(tabulado[:,0]==cual) 
        tabulado[donde,1] = tabulado[donde,1] + 1
        tabulado[donde,2] = tabulado[donde,2] + tabla[fila,1]
        fila = fila + 1

    # acumula lo recolectado por playa
    return(tabulado)

ejercicios resueltos Python 2Eva_IIT2015_T2 pdf

Ejercicio: 2Eva_IIT2015_T3 Playaton limpieza de playas

Continuación del tema 2. Propuesta de solución en Python: pyT2_pdf, pyT3_pdf

Algoritmo en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2015_T2 funcion totalportipo(tabla)
# propuesta de repaso: edelros@espol.edu.ec

import numpy as np

def totalportipo(tabla):
    # Tamaño de tabla con codigoplaya,recolectado
    n,k = tabla.shape  
    
    # verifica banderas repetido cambiando a 1
    repetidos = np.zeros(n,dtype=int)
    i = 0
    while not(i>=(n-1)):
        j = i + 1
        while not(j>=n):
            if (tabla[i,0]==tabla[j,0]):
                repetidos[j] = 1
            j = j+1
        i = i + 1
    
    # cuenta los que se eliminan
    # para ver los m que son únicos
    eliminar = 0
    fila = 0
    while not(fila>=n):
        eliminar = eliminar + repetidos[fila]
        fila = fila + 1
    m = n-eliminar

    # copiar codigos unicos en tabulado columna 0
    tabulado = np.zeros(shape=(m,3), dtype=float)
    fila = 0
    j = 0
    while not(fila>=n):
        if (repetidos[fila]==0):
            tabulado[j,0] = tabla[fila,0]
            j = j + 1
        fila = fila + 1

    # Cuenta voluntarios por playa en tabulado columna 1
    # Acumula recolectado por playa en tabulado columna 2
    fila = 0
    while not(fila>=n):
        cual = tabla[fila,0]
        # encuentra el índice en donde
        donde = np.where(tabulado[:,0]==cual) 
        tabulado[donde,1] = tabulado[donde,1] + 1
        tabulado[donde,2] = tabulado[donde,2] + tabla[fila,1]
        fila = fila + 1

    # acumula lo recolectado por playa
    return(tabulado)


# 2Eva_IIT2015_T3 Playaton limpieza de playas
voluntarios = []
opcion = 0
while not(opcion==7):
    print('1. registrar voluntario')
    print('2. registrar Kg recolectada/voluntario')
    print('3. conteo de voluntarios')
    print('4. tabular recolectado')
    print('5. Guardar archivo')
    print('6. Abrir archivo')
    print('7. Salir')
    
    opcion = int(input(' opcion:'))
    
    if (opcion==1):
        print('-- registrar voluntario --')
        ced = int(input('cédula: '))
        nom = input('nombre: ')
        pla = int(input('codigo playa: '))
        rec = 0
        registro = {'cedula':ced,
                    'nombre': nom,
                    'playa':pla,
                    'recolectado':rec}
        voluntarios.append(registro)
        print('gracias por participar')

    if (opcion==2):
        print('-- registrar Kg recolectado/voluntario --')
        ced = int(input('cédula: '))
        rec = float(input('recolectado: '))
        
        # buscar voluntario,
        # Podría buscar con index en la lista
        encontre = -1
        n = len(voluntarios)
        fila = 0
        while not(encontre>=0 or fila>=n):
            if (voluntarios[fila]['cedula']==ced):
                encontre = fila
            fila = fila + 1
        
        if (encontre>=0):
            voluntarios[encontre]['recolectado'] = rec
            print('recolectado:',rec)
        else:
            print('no esta registrado este voluntario')

    if (opcion==3):
        print('--- cuenta voluntarios ---')
        n = len(voluntarios)
        # extraer columnas codigoplaya y recoletado
        tabla = np.zeros(shape=(n,2),dtype=float)
        fila = 0
        while not(fila>=n):
          tabla[fila][0] = voluntarios[fila]['playa']
          tabla[fila][1] = voluntarios[fila]['recolectado']
          fila = fila + 1
        resultado = totalportipo(tabla)

        print('los voluntarios presentados son:',n)
        print(resultado)

    if (opcion==4):
        print('-- tabular recolectado --')
        n = len(voluntarios)
        # extraer vector codigos playas
        tabla = np.zeros(shape=(n,2),dtype=float)
        fila = 0
        while not(fila>=n):
          tabla[fila][0] = voluntarios[fila]['playa']
          tabla[fila][1] = voluntarios[fila]['recolectado']
          fila = fila + 1
        resultado = totalportipo(tabla)

        #total recolectado
        m,k = resultado.shape
        total = 0
        i = 0
        while not(i>=m):
            total = total + resultado[i,2]
            i = i + 1
        print('El total recolectado es:',total)
        print('El total por playa es: ')
        print(resultado)

    if (opcion==5):
        print('---- guardar el archivo de voluntarios ---')
        
        # prepara el modo escritura 'w' de archivo
        archivo = open('voluntarios.txt','w')
        
        n = len(voluntarios)
        fila = 0
        while not(fila>=n):

            # Crea la linea de texto de los datos
            # para un registro, separada por comas
            registro = str(voluntarios[fila]['cedula'])
            registro = registro + ',' + voluntarios[fila]['nombre']
            registro = registro + ',' +str(voluntarios[fila]['playa'])
            registro = registro + ',' +str(voluntarios[fila]['recolectado']) +'\n'

            # Escribe en el archivo
            archivo.write(registro)
            fila = fila + 1

        archivo.close()     # Cierra el archivo    
        print('archivo guardado...')

    if (opcion==6):
        print(' --- Abrir archivo de voluntarios---')
        voluntarios = []
        
        # prepara el modo lectura(read 'r') de archivo
        archivo = open('voluntarios.txt','r')
        linea = archivo.readline()

        #Hasta encontrar el final del archivo
        while (linea!=''):
            # Divide los datos por comas
            datos = linea.split(',')  
            ced = int(datos[0])
            nom = datos[1]
            pla = int(datos[2])
            rec = float(datos[3])
            
            # crea el registro diccionario para la lista
            registro = {'cedula':ced,
                        'nombre': nom,
                        'playa':pla,
                        'recolectado':rec}
            
            voluntarios.append(registro)
            # Lee la siguiente linea
            linea=archivo.readline()
            
        archivo.close()  # Cierra el archivo
        
        n = len(voluntarios)
        print(' Se recuperaron '+ str(n) + ' registros de voluntarios')
        
    if (opcion==7):
        print(' gracias por usar el software, @copyritghs')

ejercicios resueltos Python 2eva_iit2015_t3 pdf

Ejercicio: 2Eva_IT2015_T2 Diccionario electrónico

Algoritmo en Python

presentado el ejercicio iniciado en clases. Tiene tarea por desarrollar:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IT2015_T2 Diccionario electrónico
# diccionario de palabras usando listas
# Tarea: Desarrollar las opciones para archivos.

def kutipak(palabra, modo, diccionario):
    n = len(diccionario)
    traducido = '' 
    if (modo==1):
        # quichua a español
        encontre = 0
        donde = -1
        i = 0
        while not(i>=n or encontre ==1):
            if (palabra.lower() == diccionario[i][0]):
                traducido = diccionario[i][1]
                encontre = 1
                donde = i
            i = i+1
    # Tarea, desarrolle el modo 2
    
    return(traducido)

diccionario = [['man', 'al'],
               ['wasi', 'casa'],
               ['pak', 'del'],
               ['kuska', 'lugar'],
               ['pash','y'],
               ['iyayku', 'tecnología'],
               ['mañay', 'servicio'],
               ['mamallakta', 'país'],
               ['kutipak', 'traductor']]

# tema 2. PROGRAMA
opcion = -1
while not(opcion ==6):
    print('...')
    print('1. Traducir palabras')
    print('2. Traducir una frase')
    print('3. Añadir palabras al diccionario')
    print('4. Guardar archivo del diccionario')
    print('5. Abrir archivo del diccionario')
    print('6. Salir')
    
    opcion = int(input('  cual opcion: '))
##    while not(opcion>=1 and opcion<=6):
##        print(' *** revisar las opciones disponibles ***')
##        opcion = int(input('  cual opcion: '))

    if (opcion==1):
        print('==== 1. Traducir palabras')
        palabra = input('palabra a traducir: ')
        modo = int(input('(1) quichua-español, (2) español-quichua: '))
        traducida = kutipak(palabra, modo, diccionario)
        print('su significado: ', traducida)

    elif (opcion==2):
        print('==== 2. Traducir una frase')
        print('palabras separadas solo por espacios')
        frase = input('frase a traducir: ')
        modo = int(input('(1) quichua-español, (2) español-quichua: '))
        partes = frase.split(' ')
        m = len(partes)
        oracion = ''
        j = 0
        while not(j>=m):
            traducida = kutipak(partes[j], modo, diccionario)
            oracion = oracion + ' '+ traducida
            j = j+1
        print('traduccion de frase: ')
        print(oracion)

    elif (opcion==3):
        print('==== 3. Añadir palabras al diccionario')

    elif (opcion==4):
        print('==== 4. Guardar archivo del diccionario')

    elif (opcion==5):
        print('==== 5. Abrir archivo del diccionario')

    elif (opcion==6):
        print('==== Gracias por usar el software ====')
        print('==== usuario@espol.edu.ec ====')

    else:
        print(' *** revisar las opciones disponibles ***')

Ejercicio: 2Eva_IT2015_T1 kutipak() quichua-español

Algoritmo en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IT2015_T1 kutipak() quichua-español
# incluye usar el modo

# Usando diccionario[quichua][español]
diccionario = {'man':'al',
               'wasi':'casa',
               'pak':'del',
               'kuska':'lugar',
               'pash':'y',
               'iyayku':'tecnología',
               'mañay':'servicio',
               'mamallakta':'país',
               'kutipak ':'traductor'}

def kutipak(palabra, modo, diccionario):
    traducido = ''
    
    if (modo == 1):     
        if (palabra in diccionario)==1:
            traducido = diccionario[palabra]

    if (modo == 2):
        n = len(diccionario)
        encontre = ''
        for elemento in diccionario:
            if (palabra == diccionario[elemento]):
                encontre = elemento
        traducido = encontre

    return(traducido)

Ejercicio: 2Eva_IT2015_T3 Distribuye tortugas en región

Algoritmo en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IT2015_T3 Distribuye tortugas en región
import numpy as np
import random as rnd

# Tarea: Verificar que total sea menor
# que capacidad de la isla, si lo es,
# retorna matriz con -1 como isla sobrepoblada.

def distribuye(n,m,q,total):
    # Region de la isla 
    isla = np.zeros(shape=(n,m),dtype=int)
    tortuga = 1
    while not(tortuga>total):
        f = int(rnd.random()*n)+0
        c = int(rnd.random()*m)+0
        if (isla[f,c]<q):
            isla[f,c] = isla[f,c] +1
            tortuga = tortuga+1
    return(isla)