Categoría: Sol_1Eva 2010-2011-2012

Ejercicio: 1Eva_IIT2012_T2 Número camiseta equipo

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

Para el bloque de ingreso usar tres variables: día, mes y año.

Primero realice la suma de los componentes de la fecha para obtener el número de trabajo n.

Se separan los dígitos de n usando el residuo y cociente, acumulando los dígitos en s, repitiendo la operación hasta que no queden más dígitos que separar.

Si el resultado de s tiene más de un dígito, se actualiza el valor de n con s y se repite el proceso anterior para acumular dígitos hasta obtener un resultado de un dígito. Se muestra el resultado “s”.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2012_T2 Número camiseta equipo
# Propuesta: edelros@espol.edu.ec

# INGRESO
dia  = int(input('dia: '))
mes  = int(input('mes: '))
anio = int(input('anio: '))

# PROCEDIMIENTO
n = dia + mes + anio
while (n>=10):
    s = 0
    while (n>0):
        r = n%10
        n = n//10
        s = s + r
    n = s

# SALIDA
print('número buscado es: ')
print(n)

Resultado del Algoritmo

dia: 12
mes: 8
anio: 2000
número buscado es: 
4
>>> 
dia: 25
mes: 12
anio: 2000
número buscado es: 
3
>>> 

---

Diagrama de Flujo Mientras-Repita

Diagrama de Flujo Repita-Hasta

ejercicios resueltos Python 1eva_iit2012_t2 pdf

ejercicios resueltos Matlab 1eva_iit2012_t2 pdf

Ejercicio: 1Eva_IIT2012_T1 Sucesión de Padovan

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

Para este ejercicio se necesitaran 4 variables simpes, a, b y c se inicializan en 1 como indica la secuencia.

1, 1, 1, 2, 2, 3, 4, 5, 7, ...
a, b, c, d
   a, b, c, d
      a, b, c, d

El valor del siguiente término “d” es siempre la suma de a y b.

Se preparan los valores siguientes reemplazando a con b, b con c, y c con d, con el objetivo de poder repetir la operación para el siguiente término.

Un contador de términos “i” permite controlar el número de términos calculados para mostrar solo el requerido.

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

# INGRESO
n = int(input('cuál término:'))

# PROCEDIMIENTO
a = 1
b = 1
c = 1
i = 3
while (i<n):
    d = a+b
    a = b
    b = c
    c = d
    i = i+1

# SALIDA
print(d)

Resultado del algoritmo

cuál término:5
2
>>>
cuál término:6
3
>>>
cuál término:7
4
>>>

Diagrama de Flujo con Mientras-Repita

---

Lazo repita-hasta:

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

# INGRESO
n = int(input('cuál término:'))

# PROCEDIMIENTO
a = 1
b = 1
c = 1
i = 3
while not (i>=n):
    d = a+b
    a = b
    b = c
    c = d
    i = i+1

# SALIDA
print(d)

Diagrama de Flujo con Repita-Hasta

ejercicios resueltos Python 1eva_iit2012_t1 pdf

ejercicios resueltos Matlab 1eva_iit2012_t1 pdf

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.

inscripción					n
estudiante	1	2	3	4	5
empresa	4	1	4	2	4

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

control de inscritos				m
empresa	1	2	3	4
cantidad	1	1	0	3

# cuenta pasantes por empresa
cantidad = np.zeros(m+1,dtype=int)
i = 1 
while not(i>n):
    k = empresa[i]
    cantidad[k] = cantidad[k]+1
    i = i + 1

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 

# cuenta pasantes por empresa
cantidad = np.zeros(m+1,dtype=int)
i = 1 
while not(i>n):
    k = empresa[i]
    cantidad[k] = cantidad[k]+1
    i = i + 1

# literal a, empresa con mas pasantes
sinpasante = 0  # literal b
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

# literal c
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
>>> 

---

Diagrama de Flujo

ejercicios resueltos Python 1eva_iit2012_t4 pdf

ejercicios resueltos Matlab 1eva_iit2012_t4 pdf

 

Ejercicio: 1Eva_IT2012_T4 Ajustar tarifas eléctricas invierno/verano

Propuesta de solución: Archivo diagrama en pdf

---

Enfoque solo en la selección de tarifas, considerando la variable para estación verano o invierno

---

Instrucciones en Python

Condiciones en serie para estación, en árbol para valor de tarifa:

# 1Eva_IT2012_T4 Ajustar tarifas eléctricas invierno/verano

# INGRESO
consumo  = int(input(' consumo:  '))
estacion = int(input(' estacion: '))

# PROCEDIMIENTO
estacion = 1
# condicionales en arbol
if estacion ==1:
    tarifa = 0.04
    if (consumo>130):
        tarifa = 0.08
        if (consumo>500):
            tarifa = 0.11
            if (consumo>700):
                tarifa = 0.16
if estacion ==2:
    tarifa = 0.04
    if (consumo>130):
        tarifa = 0.11
        if (consumo>500):
            tarifa = 0.13
            if (consumo>700):
                tarifa = 0.26
pagar = consumo*tarifa

# SALIDA
print(' pagar:')
print(pagar)

ejercicios resueltos Python 1eva_it2012_t4 pdf

Ejercicio: 1Eva_IIT2012_T3 Hundir barco enemigo

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

Ingrese el número de municiones o disparos que se pueden hacer y las coordenadas del barco a hundir.

eje y	5
	4
	3
	2
	1
		1	2	3	4	5	eje x

Indique las coordenadas al punto de disparo y luego calcule el movimiento del barco de forma aleatoria como se indica en el enunciado. Mueva el barco a la nueva posición.

Compare si las coordenadas de disparo y la nueva posición del barco son iguales para confirmar hundimiento.

    if (bx==cx and by==cy):
       hundido = 1

Sino repita la operación desde el inicio de disparo hasta que se acaben las municiones.

while (disparo<n and hundido==0):

Instrucciones Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2012_T3 Hundir barco enemigo
# Propuesta de solución. edelros@espol.edu.ec

import random as rnd

n  = int(input('¿Cuántas municiones?: '))
bx = int(input('Barco ¿Coordenada bx?: '))
by = int(input('Barco ¿Coordenada by?: '))

hundido = 0
disparo = 0

# Juego
while (disparo<n and hundido==0):

    print('\nIntento '+str(disparo+1))
    print('Barco enemigo en ('+str(bx)+','+str(by)+')')
    cx = int(input('Disparo ¿Coordenada cx?: '))
    cy = int(input('Disparo ¿Coordenada cy?: '))

    d = int(rnd.random()*4)+1
    p = int(rnd.random()*3)+1

    if d==1:
        by = by + p
    if d==2:
        by = by - p
    if d==3:
        bx = bx + p
    if d==4:
        bx = bx - p
    if (bx==cx and by==cy):
       hundido = 1

    disparo = disparo+1

    print('Movimiento direccion:',d,
          ' con:',p,'casillas')
    print('Disparados: ',disparo)
    print('   Hundido: ',hundido)

# SALIDA
print('Barco Hundido:', hundido)
print('Disparos realizados:',disparo)

Resultado del algoritmo

¿Cuántas municiones?: 5
Barco ¿Coordenada bx?: 10
Barco ¿Coordenada by?: 10

Intento 1
Barco enemigo en (10,10)
Disparo ¿Coordenada cx?: 10
Disparo ¿Coordenada cy?: 11
Movimiento direccion: 4  con: 1 casillas
Disparados:  1
   Hundido:  0

Intento 2
Barco enemigo en (9,10)
Disparo ¿Coordenada cx?: 9
Disparo ¿Coordenada cy?: 11
Movimiento direccion: 1  con: 1 casillas
Disparados:  2
   Hundido:  1
Barco Hundido: 1
Disparos realizados: 2
>>> 

---

Diagrama de Flujo

ejercicios resueltos Python 1eva_iit2012_t3 pdf

ejercicios resueltos Matlab 1eva_iit2012_t3 pdf

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.

    # 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

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)

---

Diagrama de Flujo

ejercicios resueltos Python 1eva_it2012_t2 pdf

ejercicios resueltos Matlab 1eva_it2012_t2 pdf

Ejercicio: 1Eva_IT2012_T1 Codificar número por dígito

Propuesta de solución en Python, también se adjunta el diagrama en pdf

Ingrese un numero «original» validando que sea de tres dígitos, es decir entre 100 y 1000.

Se extrae cada dígito usando residuo y cociente de la división para 10. Aplique a cada dígito las reglas del enunciado del problema usndo condicionales.

Los dígitos se vuelven a armar en el código como resultado usando las posiciones i de cada uno de ellos (unidades, decenas, centenas).

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2012_T1 Codificar número por dígito

# INGRESO
original = int(input('número: '))

while not(original>=100 and original<1000):
    original = int(input('número: '))

# PROCEDIMIENTO
A = original
codigo = 0
i = 0
while not(A==0):
    d = A%10
    A = A//10
    
    if (d==2 or d==5 or d==7):
        d = d+1
    else:
        if (d==1 or d==4 or d==8 or d==9):
            d = d-1

    codigo = codigo + d*(10**i)
    i = i+1
    
# SALIDA
print('codificado: ', codigo)

Resultado del algoritmo

número: 472
codificado:  383
>>> 
número: 503
codificado:  603
>>> 
número: 615
codificado:  606
>>> 

---

Diagrama de Flujo

 

ejercicios resueltos Python 1Eva_IT2012_T1 pdf

Ejercicio: 1Eva_IIT2011_T3 Parchis 2 fichas

Propuesta de solución en Python

Por simplicidad, inicie solo con un jugador. Lanza el un dado para el primer jugador y avanza la posición tantas veces sea necesario hasta que llegue a la meta.

a=0
dado = int(rnd.random()*6)+1
a = a + dado

Luego incorpore al segundo jugador y observe las posiciones de cada uno hasta que llegue uno de ellos a la meta para seleccionar al ganador.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2011_T3 Parchis 2 fichas
# Tarea: implementar la selección de inicio
import random as rnd

# INGRESO
meta = 50

# PROCEDIMIENTO
a=0
b=0
while not(a>=meta or b>=meta):

    dado = int(rnd.random()*6)+1
    a = a + dado
    if (a==b):
        b = 0

    dado = int(rnd.random()*6)+1
    b = b + dado
    if (b==a):
        a = 0

if (a>=50):
    gana = 1
else:
    gana = 2

# SALIDA
print('ganador: ')
print(gana)

Ejercicio: 1Eva_IT2011_T3 Calcular ventas por región

Propuesta de solución en Python. Revise también la version en matlab en pdf

Como referencia para la solución se usa el gráfico, o la animación

Solicitar la cantidad de vendedores a participar, registrar los montos vendidos por cada vendedor y sortearlas regiones asignadas.

También es posible hacer primero el sorteo y luego pedir los montos vendidos, pero dado que no se pide mostrar las asignaciones, el orden de los bloques no afecta el resultado.

Utilizar acumuladores para los montos de cada región. Mostrar los resultados.

Tarea: Cambiarel algoritmo utilizando un vector para los acumuladores de montos por región.

Se presenta la solución por partes por didáctica:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2011_T3 Calcular ventas por región
import random as rnd
import numpy as np

# parte 1) sorteo de regiones a cada vendedor

# INGRESO
n = int(input('cuantos vendedores: '))

# PROCEDIMIENTO
region = np.zeros(n, dtype = int)
monto = np.zeros(n, dtype = float)

vendedor = 0
while not(vendedor>=n):
    donde = int(rnd.random()*4)+1
    region[vendedor] = donde
    vendedor = vendedor + 1

# parte 2) calcular montos de venta

# INGRESO DE VENTAS
vendedor = 0
while not(vendedor>=n):
    print('monto['+str(vendedor)+']: ')
    monto[vendedor] = float(input(''))
    vendedor = vendedor+1

# Total de ventas por mes
total = 0
vendedor = 0
while not(vendedor>=n):
    total = total + monto[vendedor]
    vendedor = vendedor+1

# ventas en region costa
totalcosta = 0
vendedor = 0
while not(vendedor>=n):
    if (region[vendedor]==1):
        totalcosta = totalcosta + monto[vendedor]
    vendedor = vendedor+1

# totales en vector totalregion
totalregion = np.zeros(4+1, dtype = float)
vendedor = 0
while not(vendedor>=n):
    donde  = region[vendedor]
    cuanto = monto[vendedor]
    totalregion[donde] = totalregion[donde] + cuanto
    vendedor = vendedor+1
    
# SALIDA
print('region asignada: ', region)
print('monto de cada vendedor: ', monto)
print('total de ventas por mes: ', total)
print('total de ventas en la costa', totalcosta)
print('total por regiones:  ', totalregion)

Tarea: De ser posible, reorganizar como un solo algoritmo.

---

Diagrama de Flujo

ejercicios resueltos Matlab 1eva_it2011_t3 pdf

Ejercicio: 1Eva_IT2011_T2 Subasta Inversa

Solución propuesta en Archivo matlab en pdf

Propuesta de Solución: Solicitar los datos de las ofertas por vendedor en un vector oferta(i).

Use el “algoritmo del menor” para determinar al vendedor con menor valor de oferta.

Identificado el vendedor menor, contar cuántos igualan la mejor oferta.

Si el contador es mayor que 1, sortear entre los vendedores hasta que el sorteo recaiga en un vendedor que si cumpla.

Mostrar los resultados

Tarea: convertir a instrucciones Python el siguiente diagrama de flujo:

 

 

ejercicios resueltos Matlab 1eva_it2011_t2 pdf