Categoría: Sol_2Eva 2013-2014-2015

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)

Ejercicio: 2Eva_IT2015_T3 Distribuye tortugas en región

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

Ejercicio: 2Eva_IT2015_T4 Movilidad de tortugas en región

Propuesta de solución en Python, continúa desde el tema 3:

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

def distribuye(n,m,q,total):
    isla = np.zeros(shape=(n,m),dtype = int)
    unatortuga = 1
    while not(unatortuga > total):
        fila = int(rnd.random()*n)+0
        columna = int(rnd.random()*m)+0
        if (isla[fila,columna]<q):
            isla[fila,columna] = isla[fila,columna] + 1
            unatortuga = unatortuga+1
    return(isla)

# 2Eva_IT2015_T4 Movilidad de tortugas en región
# usar funciones para operaciones intermedias
def cuentaceros(isla):
    tamano = np.shape(isla)
    n = tamano[0]
    m = tamano[1]
    cuenta = 0
    for f in range(0,n,1):
        for c in range(0,m,1):
            if (isla[f,c] ==0):
                cuenta = cuenta +1
    return(cuenta)

def muevetortuga(isla):
    tamano = np.shape(isla)
    n = tamano[0]
    m = tamano[1]
    # crear una situacion posterior,
    # donde se mueve cada tortuga
    posterior = np.zeros(shape=(n,m),dtype = int)
    for f in range(0,n,1):
        for c in range(0,m,1):
            cuantas = isla[f,c]
            if (cuantas>=1):
                tortugas = 1
                while not(tortugas>cuantas):
                    # mueve una tortuga
                    mueve = int(rnd.random()*5)+0
                    if (mueve ==1):
                        # verifica limites, sino se pierde la tortuga
                        if ((f-1)>=0 and (c-1)>=0):
                            posterior[f-1,c-1] = posterior[f-1,c-1] +1
                    if (mueve ==2):
                        if ((f-1)>=0 and (c+1)<m):
                            posterior[f-1,c+1] = posterior[f-1,c+1] +1
                    if (mueve ==3):
                        if ((f+1)=0):
                            posterior[f+1,c-1] = posterior[f+1,c-1] +1
                    if (mueve ==4):
                        if ((f+1)<n and (c+1)<m):
                            posterior[f+1,c+1] = posterior[f+1,c+1] +1
                    tortugas = tortugas +1
    return(posterior)


# INGRESO
n = int(input('filas : '))
m = int(input('columnas : '))
q = int(input('maximo por casilla : '))
total = int(input('tortugas en cautiverio : '))
# Tarea: validar que total no exceda capacidad de isla

# PROCEDIMIENTO
inicial = distribuye(n,m,q,total)
inicialceros = cuentaceros(inicial)
posterior = muevetortuga(inicial)
perdidas = np.sum(inicial)- np.sum(posterior)

# SALIDA
print('isla al inicio: ')
print(inicial)
print('casillas vacias en inicial: ', inicialceros)
print('isla despues de un periodo: ')
print(posterior)
print('tortugas perdidas: ', perdidas)

Nota: considera que si la tortuga sale de la matriz, ya no se la cuenta, desaparece, muere.

filas : 4
columnas : 6
maximo por casilla : 5
tortugas en cautiverio : 20
isla al inicio:
[[1 1 1 0 0 3]
 [0 2 1 2 0 1]
 [0 0 0 0 1 0]
 [2 2 3 0 0 0]]
casillas vacias en inicial:  12
isla despues de un periodo:
[[0 0 2 1 1 0]
 [0 0 0 0 0 0]
 [2 1 0 0 1 0]
 [0 0 0 1 0 0]]
tortugas perdidas:  11

Ejercicio: 2Eva_IIT2014_T2 Listar multas infractores metrovía

continuación del tema 1. Propuesta de solución en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2014_T2 Listar multas infractores metrovía
# Tarea: Calcular el total de multas a recaudar
import numpy as np

def multametrovia(veces,basico):
    pagar = 0
    i = 1
    while not(i>veces):
        if (i==1):
            pagar = basico + 0.1*basico
        if (i>1):
            pagar = pagar + 2*basico+0.1*basico
        i = i + 1
    return(pagar)

# 2Eva_IIT2014_T2 Listar multas infractores metrovía
# usa la funcion anterior

# INGRESO
n = int(input('cuantas infracciones: '))
i = 0
codigo = []
while not(i>=n):
    placa = input('codigo: ')
    codigo.append(placa)
    i = i + 1

# PROCEDIMIENTO

# marcar los únicos
unico = np.ones(n,dtype=int)
i = 0
penultimo = n-1
while not(i>=penultimo):
    j = i + 1
    while not(j>=n):
        if (codigo[i]==codigo[j]):
            unico[j] = 0 
        j = j + 1
    i = i + 1

# copiar en nueva lista placas únicas
infractor = []
i = 0
while not(i>=n):
    if (unico[i]==1):
        infractor.append(codigo[i])
    i = i + 1

# contar los repetidos vector veces
m = len(infractor)
veces = np.zeros(m,dtype=int)
i = 0
while not(i>=n):
    placa = codigo[i]
    
    # busca en infractores
    j = 0
    while not(j>=m):
        if (placa==infractor[j]):
            veces[j] = veces[j] + 1
        j = j + 1
    i = i + 1

# multas
multas = np.zeros(m,dtype=float)
j = 0
while not(j>=m):
    multas[j] = multametrovia(veces[j],354)
    j = j + 1

# Tarea: total a recaudar por multas

# SALIDA
print(unico)
print(infractor)
print('La lista de infractores y multas es:')
j = 0
while not(j>=m):
    print(infractor[j],multas[j])
    j = j + 1

resultado del algoritmo

cuantas infracciones: 4
codigo: 123
codigo: 456
codigo: 1020
codigo: 456
[1 1 1 0]
['123', '456', '1020']
La lista de infractores y multas es:
123 389.4
456 1132.8000000000002
1020 389.4
>>> 

Ejercicio: 2Eva_IIT2014_T1 Multas por invadir carril metrovía

Propuesta de solución en Python para tema 1, continúa en tema 2.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2014_T1 Multas por invadir carril metrovía
# Tarea: Calcular el total de multas a recaudar
import numpy as np

def multametrovia(veces,basico):
    pagar = 0
    i = 1
    while not(i>veces):
        if (i==1):
            pagar = basico + 0.1*basico
        if (i>1):
            pagar = pagar + 2*basico+0.1*basico
        i = i + 1
    return(pagar)

resultado del algoritmo

>>> multametrovia(1, 354.00)
389.4
>>> multametrovia(2, 354.00)
1132.8000000000002
>>> multametrovia(3, 354.00)
1876.2000000000003
>>> 

Ejercicio: 2Eva_IT2014_T2 Función color RGB a gris

Propuesta de solución en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IT2014_T2 Función color RGB a gris
# propuesta: edelros@espol.edu.ec

import numpy as np

def convertirgris(RGB):
    rojo  = RGB[0]
    verde = RGB[1]
    azul  = RGB[2]

    # Mezcla colores
    gris = 0.2989*rojo + 0.5870*verde + 0.1140*azul
    gris = int(gris)

    if (rojo>255 or verde>255 or azul>255):
        gris = -1
    # Tarea: verificar para colores <0
    
    return(gris)