Por simplicidad, inicie solo con un jugador. La posición en el tablero se registra en la variable a. La meta se alcanza en la casilla 50.
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.
Algoritmo en Python
# ICM00794-Fundamentos de Computación - FCNM-ESPOL# 1Eva_IIT2011_T3 Parchis 2 fichas# Tarea: implementar la selección de inicioimport random as rnd
# INGRESO
meta = 50
# PROCEDIMIENTO
a=0
b=0
whilenot(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)
Tarea: Desarrolle una versión para los 4 jugadores de Parchís.
Luego en otra versión, considere usar las 4 fichas para cada jugador.
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: Cambiar el algoritmo utilizando un vector para los acumuladores de montos por región.
# ICM00794-Fundamentos de Computación - FCNM-ESPOL# 1Eva_IT2011_T3 Calcular ventas por regiónimport 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
whilenot(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
whilenot(vendedor>=n):
print('monto['+str(vendedor)+']: ')
monto[vendedor] = float(input(''))
vendedor = vendedor+1
# Total de ventas por mes
total = 0
vendedor = 0
whilenot(vendedor>=n):
total = total + monto[vendedor]
vendedor = vendedor+1
# ventas en region costa
totalcosta = 0
vendedor = 0
whilenot(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
whilenot(vendedor>=n):
donde = region[vendedor]
cuanto = monto[vendedor]
totalregion[donde] = totalregion[donde] + cuanto
vendedor = vendedor+1
# SALIDAprint('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.
# ICM00794-Fundamentos de Computación - FCNM-ESPOL# 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)
# SALIDAprint('años transcurridos: ', anio)
Resultado del algoritmo
Banco A - Capital Inicial: 100
Banco A - Tasa Interés Anual:0.065
Banco B - Capital Inicial: 120
Banco B - Tasa Interés Anual:0.055
años transcurridos: 20
>>>
Banco A - Capital Inicial: 100
Banco A - Tasa Interés Anual:0.067
Banco B - Capital Inicial: 120
Banco B - Tasa Interés Anual:0.055
años transcurridos: 17
>>>
para poner luego el valor sorteado a cada uno, si aún no se ha repetido.
dama = int(rnd.random()*n)+(n+1)
El valor repetido se verifica revisando el estado del arreglo en la posición correspondiente, esperando que sea vacio AmigO[dama]==0, solo allí se asigna el amigo y se pasa al siguiente sorteo.
# sortea dama para cada AmigO
i = 1
while (i<=n):
dama = int(rnd.random()*n)+(n+1)
if (AmigO[dama]==0):
AmigO[dama] = i
i = i+1
# ICM00794-Fundamentos de Computación - FCNM-ESPOL# 1Eva_IIT2010_T3 Juego del amigo secreto# Propuesta de solucion. edelros@espol.edu.ecimport numpy as np
import random as rnd
# INGRESO
n = int(input('¿número de parejas?: '))
# PROCEDIMIENTO
AmigA = np.zeros(n+1,dtype=int)
AmigO = np.zeros(2*n+1,dtype=int)
# sortea dama para cada AmigO
i = 1
while (i<=n):
dama = int(rnd.random()*n)+(n+1)
if (AmigO[dama]==0):
AmigO[dama] = i
i = i+1
# sortea caballero para cada AmigA
j = n+1
while (j<=(2*n)):
caballero = int(rnd.random()*n)+1
if (AmigA[caballero]==0):
AmigA[caballero] = j
j = j+1
# SALIDAprint('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
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.
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
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.
Se usará desde la casilla 1, por lo que el tamaño del arreglo es n+1 al no usar la casilla cero.
n = int(input('¿Cuántos formularios: '))
genero = np.zeros(n+1,dtype=int)
instruccion = np.zeros(n+1,dtype=int)
i = 1
whilenot(i>n):
print('Formulario:',i)
genero[i] = int(input(' genero: '))
instruccion[i] = int(input(' instruccion: '))
i = i+1
Se inicializan los contadores al inicializar la matriz para luego procesar los datos de todos los formularios registrados.
Instrucción por género:
Masculino
Femenino
Primaria
Secundaria
Superior
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.ecimport 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
whilenot(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
whilenot(i>n):
f = instruccion[i]
c = genero[i]
tabla[f,c] = tabla[f,c]+1
i = i + 1
# SALIDAprint('Instr M F ')
f = 1
whilenot(f>3):
c = 1
cadena = ''whilenot(c>2):
cadena = cadena+' '+str(tabla[f,c])
c = c + 1
print(' '+str(f)+': '+cadena)
f = f + 1
# ICM00794-Fundamentos de Computación - FCNM-ESPOL# 1Eva_IT2010_T2 Número Omirp# Propuesta: edelros@espol.edu.ec# INGRESO
n = int(input('numero a validar omirp: '))
# PROCEDIMIENTO# revisa si es primo
esprimo = 1
i = 2
while (i<n):
r = n%i
if r==0:
esprimo = 0
i = i+1
# invierte los dígitos del número
m = n
alreves = 0
while (m>0):
r = m%10
m = m//10
alreves = alreves*10 + r
# revisa si alreves es primo
esprimoA = 1
i = 2
while (i<alreves):
r = alreves%i
if r==0:
esprimoA = 0
i = i + 1
# revisa si es omirpif (esprimo==1 and esprimoA==1):
omirp = 1
else:
omirp = 0
# SALIDAprint('es número omirp: ', omirp)
Resultado del algoritmo
numero a validar omirp: 1597
es número omirp: 1
>>>
numero a validar omirp: 1598
es número omirp: 0
>>>
Para el bloque de ingreso de piden la cantidad de modelos, con lo que se puede crear la matriz con columnas cantidad y precio. Se usa una tercera columna para calcular el valor a devolver por cada modelo.
Ejemplo:
Modelo
Cantidad
Precio
Devolver
LCD
250
400
50.000
Plasma
120
1000
60.000
LED
80
3000
120.000
...
...
...
...
Total a Devolver: 230.000
Se suman los valores a devolver para presentar el resultado.
Por simplicidad, inicie solo con un jugador. La posición en el tablero se registra en la variable a. La meta se alcanza en la casilla 50.
