Categoría: Solución 2da Evaluación

Ejercicio: 2Eva_IIT2017_T2 Reporte comercio internacional

Propuesta de solución en Python:

archivos usados: Flores.txt,  Maderas.txt
para obtener respuestas: categoriasconsolidado.txt, totalFlores, totalMaderas

totales de:  Flores
{('Estados Unidos', 'Ecuador', 'rosas'): 118568,
 ('Holanda', 'Japon', 'tulipanes'): 2384,
 ('Estados Unidos', 'Ecuador', 'girasoles'): 38284}
*** Consolidando productos:  Archivos consolidados guardados
resultados de funcion crearMatriz(): 
(array([[ 38284, 118568,      0,  69284,  69284,  48284],
       [     0,      0,   2384,      0,   3384,      0]]),
       ['Ecuador', 'Japon'],
       ['girasoles', 'rosas', 'tulipanes', 'abeto', 'cereso', 'teca'],
       {'Flores': ['girasoles', 'rosas', 'tulipanes'], 
'Maderas': ['abeto', 'cereso', 'teca']})
*** Ventas por categoria son:  Archivos venta por categoria guardados
>>> 

Instrucciones en Python:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2017_T2 reporte comercio internacional
import numpy as np

def calculaTotales(categoria):
    totales = {}

    narchivo = categoria + '.txt'
    archivo  = open(narchivo,'r')

    # Linea de encabezado
    linea = archivo.readline()
    # Primera linea de datos
    linea = archivo.readline() 
    while not(linea ==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        indice = (partes[0],partes[1],partes[2])
        cantidad = int(partes[3])
        valor = float(partes[4])

        if indice in totales:
            totales[indice] = totales[indice] + cantidad
        else:
            totales[indice] = cantidad
        linea = archivo.readline()
    archivo.close()

    return(totales)

def consolidado(nomArchivo,categorias):
    archivo = open(nomArchivo, 'w')
    for unacat in categorias:
        total = calculaTotales(unacat)

        # totales.update(total)
        for indice in total:
            comp = indice[0] 
            vend = indice[1]
            cate = unacat
            prod = indice[2]
            cant = total[indice]
            linea = comp + ',' + vend + ','
            linea = linea + cate + ',' + prod
            linea = linea + ',' + str(cant) + '\n'
            archivo.write(linea)
            
    archivo.close()

    respuesta = 'Archivos consolidados guardados'
    return(respuesta)

def ventasCategorias(nomArchivo, dicCat):
    # Por simplicidad, supone que el orden
    # en dicCat es el mismo que en
    # lista productos
    # Tarea: seleccionar los 5 vendedores mas bajos

    paisproducto = crearMatriz(nomArchivo)
    matriz     = paisproducto[0]
    vendedores = paisproducto[1]
    productos  = paisproducto[2]
    categorias = dicCat.keys()

    a = 0
    for categ in categorias:
        incluye = dicCat[categ]
        k = len(incluye)
        b = a + k
        seccion = matriz[:,a:b]
        suma = np.sum(seccion, axis=1)
        a = a + k
        
        unifica = []
        for f in range(0,len(vendedores),1):
            unifica.append([vendedores[f],suma[f]])

        narchivo = 'total'+categ+'.txt'
        archivo = open(narchivo,'w')
        for f in range(0,len(unifica),1):
            linea = unifica[f][0]+','+str(unifica[f][1])+'\n'
            archivo.write(linea)
        archivo.close()

    respuesta = 'Archivos venta por categoria guardados'
    return(respuesta)

# El examen supone que esta función ya existe.
# adicionalmete crea dicCat para hacer funcional el problema
def crearMatriz(nomArchivo):
    # Obtiene los indices para la matriz
    vendedores = []
    categoria = {}
    lista = []

    archivo = open(nomArchivo,'r')
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes =  linea.split(',')
        unvendedor = partes[1]
        unacategoria = partes[2]
        unproducto = partes[3]
        cant = int(partes[4])

        if not(unvendedor in vendedores):
            vendedores.append(unvendedor)
        if not(unacategoria in categoria):
            categoria[unacategoria] = [unproducto]
        else:
            if not(unproducto in categoria[unacategoria]):
                categoria[unacategoria].append(unproducto)
        lista.append([unvendedor,unproducto,cant])
        linea = archivo.readline()
    archivo.close()

    # Ordena los productos alfabeticamente
    productos = []
    for unacategoria in categoria:
        prod = categoria[unacategoria]
        prod.sort()
        categoria[unacategoria] = prod
        productos = productos + prod

    # Crea la matriz
    n = len(vendedores)
    m = len(productos)
    matriz = np.zeros(shape=(n,m),dtype=int)
    k = len(lista)
    for i in range(0,k,1):
        fila = vendedores.index(lista[i][0])
        columna = productos.index(lista[i][1])
        matriz[fila,columna] = matriz[fila,columna] + lista[i][2]
    respuesta = (matriz, vendedores, productos,categoria)
    return(respuesta)

# PROGRAMA
# INGRESO datos prueba
categoria = 'Flores'
categorias = ['Flores','Maderas']
nomArchivo = 'categoriasconsolidado.txt'

# PROCEDIMIENTO
totales = calculaTotales(categoria)
consolidaprod = consolidado(nomArchivo, categorias)
paisproducto = crearMatriz(nomArchivo)
dicCat = paisproducto[3]
ventacat = ventasCategorias(nomArchivo, dicCat)

# SALIDA
print('totales de: ', categoria)
print(totales)
print('*** Consolidando productos: ', consolidaprod)
print('resultados de funcion crearMatriz(): ')
print(paisproducto)
print('*** Ventas por categoria son: ', ventacat)

Ejercicio: 2Eva_IIT2016_T2 País destino para jubilados extranjeros

Propuesta de solución en Python:

requiere usar el archivo: destinosdatos.txt

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2016_T2 País destino para jubilados extranjeros

def cargarDatos(nomFile):
    datos = {}
    archivo = open(nomFile, 'r')
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        
        ciu = partes[0]
        met = partes[1]
        val = float(partes[2])
        
        if not(ciu in datos):
            datos[ciu] = {met:val}
        else:
            datos[ciu][met]= val
        linea = archivo.readline()
        
    archivo.close()
    return(datos)

def metricaPais(datos, paises):
    promedios = {}
    for unpais in paises:
        totalcanasta = 0
        totaltemperatura = 0
        ciudades = paises[unpais]
        
        for unaciudad in ciudades:
            unacanasta = datos[unaciudad]['canastaBasica']
            totalcanasta = totalcanasta + unacanasta
            unatemp = datos[unaciudad]['temperatura']
            totaltemperatura = totaltemperatura + unatemp

        # los promedios son por pais
        promediocanasta     = totalcanasta/len(ciudades)
        promediotemperatura = totaltemperatura/len(ciudades)
        promedios[unpais] = {'canastaBasica': promediocanasta,
                             'temperatura': promediotemperatura}  
    return(promedios)

def generaPaises(promedios, metrica, minimo, maximo):
    narchivo = 'cumplencon.csv'
    archivo  = open(narchivo, 'w')
    
    for unpais in promedios:
        valor = promedios[unpais][metrica]
        if (valor>=minimo and valor<=maximo):
            linea = unpais +'\n'
            archivo.write(linea)
    archivo.close
    
    mensaje = 'resultados en archivo'
    return(mensaje)


# PROGRAMA Prueba
# INGRESO
paises = {'Ecuador':{'Cuenca','Guayaquil'},
          'Colombia':{'Bogotá'}}

nomFile = 'destinosdatos.txt'

metrica = input('cual metrica: ')
minimo  = float(input('minimo: '))
maximo  = float(input('maximo: '))

# PROCEDIMIENTO
tabla = cargarDatos(nomFile)
promedios = metricaPais(tabla, paises)
cualescumplen = generaPaises(promedios, metrica, minimo, maximo)

# SALIDA
print('tabla de datos: ')
print(tabla)
print('paises')
print(paises)
print('promedios de características')
print(promedios)
print('paises de interes para el jubilado, en archivo')

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

Desarrollo del 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.

# 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

# 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

Propuesta de solución 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

Propuesta de solución 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)