s1Eva_IIT2011_T3 Parchis 2 fichas

Ejercicio: 1Eva_IIT2011_T3 Parchis 2 fichas

Propuesta de solución en Python

Inicie lanzando un dado para el primer jugador y avance su posición tantas veces sea necesario hasta que llegue a la meta.

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.

# 1Eva_IIT2011_T3 Parchis 2 fichas
# Tarea: implementar la selección de inicio
import random as rnd

# INGRESO
meta = 50

a=0
b=0

# PROCEDIMIENTO
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(gana)

s1Eva_IT2011_T3 Calcular ventas por región

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:

# 1Eva_IT2011_T3 Calcular ventas por región
import random as rnd
import numpy as np

# parte 1) sorteo de regiones a cada vendedor

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: ')
print(region)
print('monto de cada vendedor: ')
print(monto)
print('total de ventas por mes: ')
print(total)
print('total de ventas en la costa')
print(totalcosta)
print('total por regiones:  ')
print(totalregion)

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

s1Eva_IIT2010_T3 Juego del amigo secreto

Ejercicio: 1Eva_IIT2010_T3 Juego del amigo secreto

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

iniciar el sorteo con banderas de amigo/amiga en cero, para poner luego el valor sorteado a cada uno, si aún no se ha repetido.

# 1Eva_IIT2010_T3 Juego del amigo secreto
# Propuesta de solucion. edelros@espol.edu.ec

import numpy
import random

# INGRESO
n = int(input('¿número de parejas?: '))

# PROCEDIMIENTO
AmigA = numpy.zeros(n+1,dtype=int)
AmigO = numpy.zeros(2*n+1,dtype=int)

i = 1
while (i<=n):
    dama=int(random.random()*n)+(n+1)
    if (AmigO[dama]==0):
        AmigO[dama] = i
        i=i+1

j = n+1
while (j<=(2*n)):
    caballero = int(random.random()*n)+1
    if (AmigA[caballero]==0):
        AmigA[caballero] = j
        j=j+1

# SALIDA
print('pareja de caballeros')
i = 1
while (i<=n):
    print(i,' , ',AmigA[i])
    i = i+1
print('pareja de damas')
j = n+1
while (j<=(2*n)):
    print(j,' , ',AmigO[j])
    j = j+1

s1Eva_IIT2010_T1 Censo de instrucción por género

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

# 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

s1Eva_IIT2012_T4 Informe de pasantías

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]

# 1Eva_IIT2012_T4 Informe de pasantías
# propuesta: edelros@espol.edu.ec

import numpy

# INGRESO
n = int(input('cuántos estudiantes:'))
m = int(input('cuantas empresas:'))
empresa = numpy.zeros(n+1,dtype=int)
i = 1
while not(i>n):
    empresa[i] = input('registro empresa:')
    i = i+1

# PROCEDIMIENTO
cantidad = numpy.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: ')
print(mayor)
print('empresas sin pasante: ')
print(sinpasante)
print('promedio pasantes por empresa: ')
print(prm)

s1Eva_IT2012_T2 Juego de carreras con dados

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.

# 1Eva_IT2012_T2 Juego de carreras con dados
# propuesta: edelros@espol.edu.ec

import random

# 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(random.random()*6)+1
    dado2 = int(random.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(random.random()*6)+1
        dado2 = int(random.random()*6)+1
        A = A+(dado1+dado2)

    # Lanzamiendo Jugador B
    dado1 = int(random.random()*6)+1
    dado2 = int(random.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(random.random()*6)+1
        dado2 = int(random.random()*6)+1
        B = B+dado1+dado2
if (A>B):
    gana = 1
else:
    gana = 2

# SALIDA
print(gana)

 

s1Eva_IIT2012_T3 Hundir barco enemigo

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.

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. Sino repita la operación desde el inicio de disparo hasta que se acaben las municiones.

# 1Eva_IIT2012_T3 Hundir barco enemigo
# Propuesta de solución. edelros@espol.edu.ec

import random

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(random.random()*4)+1
    p = int(random.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:'+str(d)+', '+str(p)+' casillas')
    print('Disparados: '+str(disparo)+ ', Hundido: '+str(hundido))

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

s1Eva_IIT2010_T2 Venta de pasajes tren turístico

Ejercicio: 1Eva_IIT2010_T2 Venta de pasajes tren turístico

Solución propuesta:  py_pdf, versión matlab m_pdf

Inicialmente desarrolle la venta para un solo pedido/comprador, así encontrará las partes principales de la venta y hace el primer esquema del procedimiento a seguir.

En una segunda versión, agregue las demás opciones de control, tales como contadores y acumuladores para controlarlos turnos o la venta de asientos del tren.

En este proceso se añade un lazo para repetir, y se termina mostrando los resultados de boletos vendidos, el dinero cobrado y el total devuelto.

Tarea: Prestar atención en la venta cuando quedan pocos boletos y el usuario quiere comprar más de los que están disponibles

# 1Eva_IIT2010_T1 Venta de pasajes tren turístico
# Propuesta: edelros@espol.edu.ec

turnomax = int(input('¿cuántos turnos?: '))
capacidad = int(input('capacidad del tren?: ')) 

pesodolar = 2.50
pesoeuro = 3.25
precio = 7.00
vendido = 0
cobrado = 0.00
devuelto = 0.00

turno = 1
while (turno<=turnomax and vendido<=capacidad):
    print('Turno:')
    print(turno)
    pedido = int(input('¿cuántos pasajes?: '))
    print('   Monedas: 1.Dolar 2.Euro 3.Peso')
    moneda = int(input(' ¿Tipo Moneda?: '))
    cantidad = float(input(' ¿Cantidad de Dinero?: '))

    if (moneda==1):
        valor = cantidad*pesodolar
    if (moneda==2):
        valor = cantidad*pesoeuro
    if (moneda==3):
        valor = cantidad

    pago=pedido*precio
    if (pago<=valor and((vendido+pedido)<capacidad)):
        vendido = vendido+pedido
        cobrado = cobrado+pago
        cambio = valor-pago
        devuelto = devuelto+cambio

        print('Se vendieron Boletos: ')
        print(pedido)
        print('su cambio: ')
        print(cambio)
    else:
        print('no es dinero suficiente')

    turno = turno+1

# SALIDA
print('pasajes vendidos: ')
print(vendido)
print('pesos cobrados: ')
print(cobrado)
print('pesos devueltos: ')
print(devuelto)

s1Eva_IT2011_T1 Ahorros de Juan vs Pedro

Ejercicio: 1Eva_IT2011_T1 Ahorros de Juan vs Pedro

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

Ingresar los datos para cada depositante en variables separadas.

Luego, calcular por cada año los saldos para cada depositante, repitiendo hasta que se cumpla la condición que Juan tenga más dinero que Pedro.

La variable “año” es un contador simple que inicia en cero, en finanzas significa el momento en que se deposita.

Cuando termina el año completo se considera incrementado en 1.

# 1Eva_IT2011_T1 Ahorros de Juan vs Pedro
# Propuesta: edelros@espol.edu.ec

# INGRESO
ca = float(input('Banco A - Capital Inicial : '))
ra = float(input('Banco A - Tasa Interés Anual:'))
cb = float(input('Banco B - Capital Inicial: '))
rb = float(input('Banco B - Tasa Interés Anual:'))

# PROCEDIMIENTO
anio = 0
sa = ca
sb = cb

while (sa<=sb):
    anio = anio+1
    sa = ca*((1+ra)**anio)
    sb = cb*((1+rb)**anio)

# SALIDA
print(anio)

s1Eva_IIT2012_T2 Número camiseta equipo

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, mesy 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”.

# 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)