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

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)

Ejercicio: 2Eva_IT2014_T3 Imagen RGB a gris

continuación del tema 2, solución propuesta 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)

# 2Eva_IT2014_T3 Imagen RGB a gris
def fotoagris(imagen):
    color,n,m   = np.shape(imagen)
    blanconegro = np.zeros(shape=(n,m),dtype=int)

    # por cada pixel
    fila = 0
    while not(fila>=n):
        columna = 0
        while not(columna>=m):
            rojo  = imagen[0,fila,columna]
            verde = imagen[1,fila,columna]
            azul  = imagen[2,fila,columna]
            # para convertir
            RGB  = [rojo,verde,azul]
            gris = convertirgris(RGB)
            # poner el punto en gris
            blanconegro[fila,columna] = gris

            columna = columna + 1
        fila = fila + 1

    return(blanconegro)

Ejemplo de ejecución. Se proporciona la imagen como aun arreglo[color,fila,columna]
Puede copiar los valores de imagen y pegarlo en la linea de instruccion>>>
Luego invocar a la funcion fotoagris(imagen)

>>>imagen=np.array([[[12, 27, 42, 46, 74],
        [ 3, 21, 33, 48, 67],
        [ 5, 18,  0, 57, 73],
        [ 6, 25, 31, 52, 69],
        [13, 24, 40, 54, 64]],

       [[13, 26, 40, 46, 66],
        [15, 23, 45, 55, 62],
        [ 3, 22,  0, 48, 70],
        [ 6, 24, 39, 58, 68],
        [ 8, 29, 35, 56, 72]],

       [[ 5, 28, 37, 58, 64],
        [ 7, 24, 34, 48, 75],
        [ 9, 17,  0, 50, 62],
        [12, 30, 43, 56, 68],
        [ 4, 26, 45, 49, 74]]])
>>> fotoagris(imagen)
array([[11, 26, 40, 47, 68],
       [10, 22, 40, 52, 64],
       [ 4, 20,  0, 50, 69],
       [ 6, 24, 37, 55, 68],
       [ 9, 27, 37, 54, 69]])

Ejercicio: 2Eva_IT2014_T1 Palabras con eco

Propuesta de solución en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IT2014_T1 Palabras con eco
# TAREA: solo compara la ultima letra
#        completar para al menos tres letras

# INGRESO
frase = input('frase: ')

# PROCEDIMIENTO
eco = 1
n = len(frase)

# ultima letra de la ultima palabra
a = frase[n-1]

# ultima letra de la penultima palabra
# Buscar letra en la otra palabra
b = ''
i = n-1
while (i>0):
    if (frase[i]==' '):
        b = frase[i-1]
    i = i - 1

# letras eco
if not(a==b):
    eco = 0
# Completar para al menos las tres ultimas letras

# SALIDA
print(eco)

resultado del algoritmo

>>> 
frase: coso oloroso
1
>>> 
frase: casa erwq
0

Ejercicio: 2Eva_IIT2013_T2 Verificar secuencia ADN

Propuesta de solución en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2013_T2 Verificar secuencia ADN
# propuesta: edelros@espol.edu.ec

def ordenados(cadena):
    n = len(cadena)
    cadena  = cadena.upper()
    validos = 'ACGT'
    pares   = 0

    # solo hasta penúltimo
    i = 0
    while not(i>=(n-1)): 
        elemento  = cadena[i]
        elemento2 = cadena[i+1]
        if (elemento<=elemento2):
            pares = pares + 1
        i = i + 1
        
    # validar elementos en cadena
    noADN = 0
    i = 0
    while not(i>=n):
        elemento = cadena[i]
        if not(elemento in validos):
            noADN = noADN - 1
        i = i + 1

    # corrige de ser necesario
    if (noADN<0): 
        pares = noADN
        
    return(pares)

Ejemplo

>>> cadena='CCGAATCGTA'
>>> ordenados(cadena)
6
>>> cadena='CBGAATCGWA'
>>> ordenados(cadena)
-2

Ejercicio: 2Eva_IT2013_T2 Una Tabla de Bingo con arreglos

2Eva_IT2013_T1 Función sorteoentre(k,a,b)

Propuesta de solución en Python, continua desde tema 1:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# propuesta: edelros@espol.edu.ec

# 2Eva_IT2013_T1 Una Tabla de Bingo
import random as rnd
import numpy as np

def sorteoentre(k,a,b):
    suertudos = []
    i = 0
    while not(i>=k):
        sorteo = int(rnd.random()*(b-a+1))+a
        if not(sorteo in suertudos):
            suertudos.append(sorteo)
            i = i+1
    return(suertudos)

# 2Eva_IT2013_T2 Una Tabla de Bingo
n = 5
#Rango inicial de B [1,15]
a = 1  
b = 15
incremento = 15

# PROCEDIMIENTO
tabla = np.zeros(shape=(n,n),dtype=int)
columna = 0
while not(columna>=n):
    datos = sorteoentre(n,a,b)
    for fila in range(0,n,1):
        tabla[fila,columna]=datos[fila]
    a = a + incremento
    b = b + incremento
    columna = columna + 1
    
# corrige el cero en la posicion central
mitad = n//2
tabla[mitad,mitad] = 0

# SALIDA
print(tabla)

Ejemplo:

>>> ================================ RESTART ==========
>>> 
[[ 4 28 37 51 63]
 [15 18 45 56 74]
 [13 23  0 48 69]
 [ 2 20 34 58 72]
 [ 3 16 32 50 71]]
>>> ================================ RESTART ==========
>>> 
[[ 2 17 37 58 75]
 [13 24 45 53 65]
 [ 7 19  0 51 73]
 [15 23 36 52 69]
 [ 3 30 39 47 67]]
>>>

 

Ejercicio: 2Eva_IT2013_T1 Función sorteoentre(k,a,b)

Solución propuesta en Python, continúa en Tema 2.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IT2013_T1 Una Tabla de Bingo
# propuesta: edelros@espol.edu.ec

import random as rnd
import numpy as np

def sorteoentre(k,a,b):
    suertudos = []
    i = 0
    while not(i>=k):
        sorteo = int(rnd.random()*(b-a+1))+a
        if not(sorteo in suertudos):
            suertudos.append(sorteo)
            i = i+1
    return(suertudos)

resultado del algoritmo

>>> sorteoentre(5,1,15)
[11, 14, 7, 10, 6]
>>> sorteoentre(5,16,30)
[17, 18, 26, 30, 27]
>>>