Categoría: Solución 1ra Evaluación

Ejercicio: 1Eva_IIT2010_T1 Censo de instrucción por género

Propuesta de solución en Python: py_pdf, también en matlab: m_pdf

Los datos se almacenan en vectores y se los tabula/cuenta en una matriz.  Las filas representan la instrucción y columna el género.

Se inicializan los contadores al inicializar la matriz para luego procesar los datos de todos los formularios registrados.

Para facilitar la lectura del algoritmo se usan como variables f y c para referenciar las filas y columnas. Una forma más larga de solución podría usar contadores individuales para contar primaria/masculino, primaria/femenino, etc.

Tarea: validar el ingreso de género e instrucción por cada formulario

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2010_T1 Censo de instrucción por género
# propuesta: edelros@espol.edu.ec

import numpy as np

#INGRESO
n = int(input('¿Cuántos formularios: '))

genero = np.zeros(n+1,dtype=int)
instruccion = np.zeros(n+1,dtype=int)

i = 1
while not(i>n):
    print('Formulario:',i)
    genero[i] = int(input('  genero: '))
    instruccion[i] = int(input('  instruccion: '))
    i = i+1

# PROCEDIMIENTO
tabla = np.zeros(shape=(3+1,2+1),dtype=int)
i = 1
while not(i>n):
    f = instruccion[i]
    c = genero[i]
    tabla[f,c] = tabla[f,c]+1
    i = i + 1

# SALIDA
print('Instr  M  F ')
f = 1
while not(f>3):
    c = 1
    cadena = ''
    while not(c>2):
        cadena = cadena+' '+str(tabla[f,c])
        c = c + 1
    print('   '+str(f)+': '+cadena)
    f = f + 1

Resultado del algoritmo

¿Cuántos formularios: 5
Formulario: 1
  genero: 1
  instruccion: 2
Formulario: 2
  genero: 1
  instruccion: 2
Formulario: 3
  genero: 2
  instruccion: 1
Formulario: 4
  genero: 2
  instruccion: 1
Formulario: 5
  genero: 2
  instruccion: 3
Instr  M  F 
   1:  0 2
   2:  2 0
   3:  0 1
>>> 

Ejercicio: 1Eva_IIT2012_T4 Informe de pasantías

Propuesta de solución en Python: py_pdf, también en versión matlab: m_pdf

Solicitar los valores de n, m y los datos del arreglo empresa para cada estudiante.

Inicializar los contadores de cantidad por empresa en cero e iniciar el proceso de conteo de estudiantes por empresa.

Para el literal a, se usará el algoritmo del mayor para el arreglo de cantidad, para la pregunta b un contador permite registrar cuántas no tienen pasantes.

El promedio es más sencillo de calcular.

Tarea: Validar que los números de empresas ingresadas en rango de[1,m]

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2012_T4 Informe de pasantías
# propuesta: edelros@espol.edu.ec

import numpy as np

# INGRESO
n = int(input('cuántos estudiantes: '))
m = int(input('cuantas empresas: '))

empresa = np.zeros(n+1,dtype=int)
i = 1
while not(i>n):
    empresa[i] = input('registro empresa: ')
    i = i + 1

# PROCEDIMIENTO
cantidad = np.zeros(m+1,dtype=int)

i = 1
while not(i>n):
    k = empresa[i]
    cantidad[k] = cantidad[k]+1
    i = i + 1

sinpasante = 0
mayor = 1

k = 1
while not(k>m):
    if (cantidad[k]>cantidad[mayor]):
        mayor = k
    if (cantidad[k]==0):
        sinpasante = sinpasante+1
    k = k + 1

prm = n/(m-sinpasante)

# SALIDA
print('la empresa con más pasantes es: ', mayor)
print('empresas sin pasante: ', sinpasante)
print('promedio pasantes por empresa: ', prm)

Resultado del algoritmo

cuántos estudiantes:5
cuantas empresas: 4
registro empresa: 2
registro empresa: 1
registro empresa: 3
registro empresa: 2
registro empresa: 4
la empresa con más pasantes es:  2
empresas sin pasante:  0
promedio pasantes por empresa:  1.25
>>> 

Ejercicio: 1Eva_IIT2007_T3 Garantías de prestamos IESS

Propuesta de solución en Python:  py_pdf, también en versión matlab: m_pdf

Para el ejemplo, por simplicidad se usan cédulas de 3 dígitos; también se supone que no existen elementos repetidos dentro de cada arreglo.

En la nota se indica que las listas de las cédulas de los afiliados tienen tamaño diferente, además el ingreso de datos es separado por tener origen de datos diferentes.

Al inicio del algoritmo, se supondrá que ningún afiliado cumple con los requisitos, por lo que se usa un arreglo de banderas de cumple o no cumple  (1 ó 0).

Realizar una búsqueda ordenada de números de cédula:
– para cada cédula de reserva[i] con n elementos
– realizar una búsqueda en el arreglo de cesantía[j] para los m elementos.

Repetir el proceso, marcando el arreglo de banderas, cumple, cada vez que se encuentra un valor repetido entre ambas listas.

Tarea: Realizar el ejercicio, construyendo un tercer arreglo con solamente los elementos que cumplen con la condición.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2007_T3 Garantías de prestamos IESS
# propuesta: edelros@espol.edu.ec

import numpy as np

# INGRESO

# datos de afiliados con fondo de reserva
n = int(input('Afiliados con Fondo de Reserva: '))
freserva = np.zeros(n+1,dtype=int)
i = 1
while not(i>n):
    print(i)
    freserva[i] = input('ingrese cedula:')
    i = i + 1

# datos de afiliados con cesantía
m = int(input('Afiliados con Cesantia: '))
cesantia = np.zeros(m+1,dtype=int)
j = 1
while not(j>m):
    print(j)
    cesantia[j] = input('ingrese cedula:')
    j = j + 1

# PROCEDIMIENTO

# Hipotesis: Ninguno cumple requisito
cumple = np.zeros(n+1,dtype=int)

# Revisa listado buscando iguales
total = 0
i = 1
while not(i>n):
    j = 1
    while not(j>m or cumple[i]==1):
        if freserva[i]==cesantia[j]:
            cumple[i] = 1
            total = total + 1
        j = j + 1
    i = i + 1

# SALIDA: Muestra cedulas de los que cumplen requisito
print('Cumplen requisitos:')
print(total)
print('listado: ')
i = 1
while not(i>n):
    if (cumple[i]==1):
        print(freserva[i])
    i = i + 1

ejemplo de resultado del algoritmo

Afiliados con Fondo de Reserva: 3
1
ingrese cedula:123
2
ingrese cedula:234
3
ingrese cedula:345
Afiliados con Cesantia: 2
1
ingrese cedula:123
2
ingrese cedula:345
Cumplen requisitos:
2
listado: 
123
345
>>> 

Ejercicio: 1Eva_IT2008_T2 Criba de Eratóstenes

Propuesta de solución en Python: py_pdf, también en versión matlab: m_pdf

Llenar un arreglo de marcas o tachado con la hipótesis que todos son primos(1).

La prueba de hipótesis consiste en usar un indicador para el número de criba, y otro indicador i para anular marcando con cero (0) las posiciones de los múltiplos.

Inicie eliminando los múltiplos de 2, para luego cambiar a los múltiplos de 3, etc.

Mostrar como resultado solo aquellos números mantienen en marcas válidas (1).

Tarea: Analizar si es necesario hacer funcionar el algoritmo de la prueba de hipótesis hasta n o un número menor. Realizar la validación que n sea mayor que 1.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2008_T2 Criba de Eratóstenes
# Propuesta: edelros@espol.edu.ec

import numpy as np

# INGRESO
n = int(input('primos menores que: '))

# PROCEDIMIENTO
marcado = np.zeros((n+1),dtype=int)

# hipotesis: todos son primos
criba = 2
while (criba<=n):
    marcado[criba] = 1
    criba = criba+1

# no son primos los múltiplos 
criba = 2
while (criba<=n):

    # revisa el primer múltiplo
    i = criba * 2
    while (i<=n):
        marcado[i] = 0
        i = i + criba
    criba = criba+1

# SALIDA
criba = 2
while (criba<=n):
    if marcado[criba]==1:
        print(criba)
    criba = criba+1

resultado del algoritmo

primos menores que: 30
2
3
5
7
11
13
17
19
23
29
>>> 

Ejercicio: 1Eva_IIT2002_T2 Color de placas de vehículos

Propuesta de solución en Python: py_pdf , también en matlab: matlab en pdf

Para el ejercicio se requiere el uso de vectores para almacenar cada placa y procesar los datos en el bloque de procedimiento.

Como todos los datos de entrada se han simplificado a la parte numérica de la placa, se usarán arreglos, aprovechando para practicar con numpy.

En el procedimiento se extrae una placa de un auto para obtener el dígito de las unidades. Con el dígito se puede usar condicionales para indicar cuál es el color que le corrresponde y contar la placa de cada color asignado.

Se continúa con el siguiente auto hasta completar todos los autos registrados en el arreglo.

Podría intentar realizar el ejercicio con listas, para comparar como se aplican los conceptos.

Tarea: validar que el número de vehículos sea positivo mayor que 0, validar que sean solo tres dígitos en cada placa.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2002_T2 Color de placas de vehículos
# propuesta: edelros@espol.edu.ec

import numpy

# INGRESO
n = int(input('cuántos autos: '))

placa = numpy.zeros(n+1,dtype=int)
auto = 1
while not(auto>n):
    print('placa[',auto,']: ')
    placa[auto] = int(input('  : '))
    auto = auto+1

# PROCEDIMIENTO
# contadores por color
color = numpy.zeros(5+1,dtype=int)

# analiza cada auto
auto = 1
while not(auto>n):
    digito = placa[auto]%10
    if (digito==1 or digito==2):
        color[1] = color[1]+1
    if (digito==3 or digito==4):
        color[2] = color[2]+1
    if (digito==5 or digito==6):
        color[3] = color[3]+1
    if (digito==7 or digito==8):
        color[4] = color[4]+1
    if (digito==9 or digito==0):
        color[5] = color[5]+1
    auto = auto+1

# SALIDA
print('Autos por cada color:')
k = 1
while not(k>5):
    print('Color tipo ',k,'= ',color[k])
    k = k+1

Ejercicio: 1Eva_IIT2008_T1 Odometro OCTAL

Propuesta de solución en Python: py_pdf, también en matlab: m_pdf

Se usa el concepto para cambio de base numérica, se extrae cada dígito para acumular el valor ponderando por cada posición referenciada con la variable i.

Si se usa residuo de la división para 10, el primer digito a extraer es el menos significativo (unidades).

Se acumulan los valores de acuerdo a la ponderación o peso por posición y se repite hasta que no queden dígitos que ponderar.

Para repasar: Bases Numéricas Introducción

Tarea: validar que el número es octal (rango de dígitos entre 0-7)-

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2008_T1 Odometro OCTAL
# Propuesta de solución. edelros@espol.edu.ec
# Tarea: Validar que el ingreso sea en octal.

# INGRESO
octal = int(input('¿numero en octal?: '))

# PROCEDIMIENTO
i = 0
decimal = 0
while (octal>0):
    r = octal%10
    octal = octal//10
    decimal = decimal+r*(8**i)
    i = i + 1

# SALIDA
print('valor en decimal: ')
print(decimal)

Resultado del algoritmo

Observación: Tener en cuenta que no se ha validado que el número octal solo debe tener dígitos entre 0 y 7.

¿numero en octal?: 27
valor en decimal: 
23
>>> 
¿numero en octal?: 14
valor en decimal: 
12
>>> 

Ejercicio: 1Eva_IT2012_T2 Juego de carreras con dados

Propuesta de solución en Python: py_pdf, también en matlab: m_pdf

Se establece el nivel del juego pidiendo el tamaño del tablero, que puede ser variable para facilitar la simulación a tableros más pequeños.

Se valida que el tamaño del tablero sea un número positivo.

Los jugadores A y B inician en la casilla de partida, fuera del tablero, marcada con 0. Por lo que se usa un acumulador para cada jugador.

Primero lanzará el jugador A, que si está en la casilla de partida y sus dados salen iguales se avanza a la primera casilla.

Si el jugador está en el tablero solo queda avanzar verificando que exista casilla de premio.

Se repite el proceso para el otro jugador, hasta que uno de ellos sobrepase la meta.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2012_T2 Juego de carreras con dados
# propuesta: edelros@espol.edu.ec

import random as rnd

# INGRESO
n = int(input('Tamaño tablero: '))
while (n<0):
    print('tablero debe tener casillas')
    n = int(input('Tamaño tablero: '))

# PROCEDIMIENTO
A = 0
B = 0
while (A<=n and B<=0):
    
    # Lanzamiendo Jugador A
    dado1 = int(rnd.random()*6)+1
    dado2 = int(rnd.random()*6)+1
    if (A==0 and dado1==dado2):
        A = 1
    if (A>0):
        A = A + dado1 + dado2
    if (A==2 or A==17 or A==30 or A==42):
        dado1 = int(rnd.random()*6)+1
        dado2 = int(rnd.random()*6)+1
        A = A + dado1 + dado2

    # Lanzamiendo Jugador B
    dado1 = int(rnd.random()*6)+1
    dado2 = int(rnd.random()*6)+1
    if (B==0 and dado1==dado2):
        B = 1
    if (B>0):
        B = B + dado1 + dado2
    if (B==2 or B==17 or B==30 or B==42):
        dado1 = int(rnd.random()*6)+1
        dado2 = int(rnd.random()*6)+1
        B = B + dado1 + dado2
        
if (A>B):
    gana = 1
else:
    gana = 2

# SALIDA
print('ganador: ',gana)

Ejercicio: 1Eva_IT2008_T3 Simular Precio del Petróleo

Propuesta de solución en Python: py_pdf

También como diagrama en pdf y en versión matlab: m_pdf

Se deja la pregunta c) como tarea a fin de que se desarrolle el problema usando un arreglo.

Se ingresa la cantidad de días del mes, o se puede considerar directamente 30, también es opcional ingresar el rango de precio mínimo y precio máximo, que son los límites del número aleatorio.

Para la pregunta a) se calcula el promedio como el acumulado de precios de cada día dividido para los n días.

Enla pregunta b) se usa el algoritmo del menor, con la hipótesis que el díamenor es el primero, y que el precio menor es el máximo posible, a fin que se reemplace con el primer menor encontrado.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2008_T3 Simular Precio del Petróleo
# Propuesta: edelros@espol.edu.ec
# Tarea: Realizar el literal c)

import random as rnd

# INGRESO
n=int(input('días del mes: '))

# PROCEDIMIENTO
prcmax = 150
prcmin = 130
rango  = prcmax-prcmin+1
diamenor = 1
pmenor = prcmax

dia = 1
total = 0
while (dia<=n):
    precio = int(rnd.random()*rango)+prcmin
    total  = total+precio

    if (precio<pmenor):
        diamenor = dia
        pmenor   = precio

    dia = dia+1

promedio = total/n

# SALIDA
print('promedio: ')
print(promedio)
print('día de menor precio:')
print(diamenor)

---

Versión Usando Arreglos:

Propuesta de solución Python: py_pdf, también en versión matlab: m_pdf

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2008_T3 Simular Precio del Petróleo
# Tema 3. Precio petroleo-Arreglo
# Propuesta: edelros@espol.edu.ec

import random as rnd
import numpy as np

# INGRESO
n = int(input('días del mes: '))

# PROCEDIMIENTO
prcmax = 150
prcmin = 130
rango  = prcmax-prcmin+1
precio = np.zeros((n+1),dtype=int)

# algoritmo del promedio
total = 0
dia   = 1
while (dia<=n):
    precio[dia] = int(rnd.random()*rango)+prcmin
    total = total + precio[dia]
    dia   = dia + 1

promedio = total/n

# algoritmo del menor
diamenor = 1
dia = 1
while (dia<=n):
    if precio[dia]<precio[diamenor]:
        diamenor = dia
    dia = dia + 1

# algoritmo precio superior al promedio
superior = 0
dia = 1
while (dia<=n):
    if precio[dia]>promedio:
        superior = superior + 1
    dia = dia + 1

# SALIDA
print('promedio: ')
print(promedio)
print('día de menor precio:')
print(diamenor)
print('días con precio sobre promedio:')
print(superior)

Resultado del algoritmo

días del mes: 30
promedio: 
140.06666666666666
día de menor precio:
14
días con precio sobre promedio:
16
>>> 

Ejercicio: 1Eva_IIT2004_T3 Estimar π por Montecarlo

Propuesta de solución en Python: py_pdf, también en versión matlab: m_pdf

Ingresar n como la cantidad de puntos en el plano a ubicar de forma aleatoria dentro del rango del cuadrado que inscribe al círculo.

Usar una variable “k” como el contador para los puntos que caen dentro del círculo.

Al generar cada punto se puede calcular la distancia al centro mediante Pitágoras.

Se repite el proceso para n puntos y al final se calcula el valor estimado de pi acorde a la relación presentada.

Nota: no se usa como variable la palabra “pi” debido a que es nombre de variable reservada.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2004_T3 Estimar π por Montecarlo
# Propuesta de solución. edelros@espol.edu.ec
# Considera todo el circulo

import random as rnd
import numpy as np

# INGRESO
n = int(input('¿Cuántos puntos?: '))

# PROCEDIMIENTO
k = 0
i = 0
while (i<n):
    x = (rnd.random()*2)-1
    y = (rnd.random()*2)-1
    d = np.sqrt(x**2+y**2)
    if (d<=1):
        k = k+1
    i = i+1

z = 4*k/n

# SALIDA
print('Pi estimado es:')
print(z)

la estimación de π con números aleatorios que se ubican dentro del círculo de radio 1 es:

¿Cuántos puntos?: 1000
Pi estimado es:
3.196
>>> 
¿Cuántos puntos?: 1000
Pi estimado es:
3.188
>>> 

Ejercicio: 1Eva_IT2007_T1 Tiro al blanco con dardos

Propuesta de solución en Python: python en pdf,
también en version matlab en pdf

Sea un punto aleatorio representado por sus valores en x, y en el rango del cuadrado que contiene a los círculos.

Se utiliza acumuladores de premios para cada franja de color, cuyo valor se determina mediante la comparación de la distancia del punto al centro.

Se repite el procedimiento para los n puntos, para al final mostrar el valor acumulado de premio.

Nota: Discutir sobre la validación de dardos en los límites (frontera, borde) del círculo.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2007_T1 Juego Tiro al Blanco con Dardos
# Propuesta solucion: edelros@espol.edu.ec

import random as rnd
import math

# INGRESO
n = int(input('numero de dardos: '))

# PROCEDIMENTO
premio = 0
i = 0
while (i<n):
    x = (rnd.random()*160)-80
    y = (rnd.random()*160)-80
    d = math.sqrt(x**2+y**2)

    if (d<10):
        premio = premio + 50
    if (d>=10 and d<40):
        premio = premio + 40
    if (d>=40 and d<80):
        premio = premio + 30

    i = i+1

# SALIDA
print(' El total ganado es:')
print(premio)

Respuesta del algoritmo

numero de dardos: 10
 El total ganado es:
280
>>> 
numero de dardos: 10
 El total ganado es:
220
>>> 

---

Desarrollo con lazo repita-hasta

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1ra Evaluación I Término 2007 - 2008
# Tema 1. Tiro al blanco
# Propuesta solucion: edelros@espol.edu.ec

import random as rnd
import math

n = int(input('numero de dardos: '))

# PROCEDIMIENTO
premio = 0
i = 0
while not(i>=n):
    x = (rnd.random()*160)-80
    y = (rnd.random()*160)-80
    d = math.sqrt(x**2+y**2)

    if (d<10):
        premio = premio+50
    if (d>=10 and d<40):
        premio = premio+40
    if (d>=40 and d<80):
        premio = premio+30

    i = i+1

# SALIDA
print(' El total ganado es:')
print(premio)