s1Eva_IT2008_T2 Criba de Eratóstenes con Python

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

# PROCEDIMIENTO
marcado = np.zeros((n+1),dtype=int)
# hipotesis: todos son primos
criba = 2
while (criba<=n):
    marcado[criba] = 1
    criba = criba+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
>>> 

diagrama de flujo Criba de Eratóstenes 01

diagrama de flujo Criba de Eratóstenes 02

diagrama de flujo Criba de Eratóstenes 03


Otra forma de plantear el algoritmo

# 1ra Evaluación I Término 2008
# Tema 2. Criba de Eratóstenes
import numpy as np

# INGRESO
n = int(input('cuantos numeros analiza: '))

# PROCEDIMIENTO
# vector de números naturales
natural = np.zeros(n, dtype=int)
posicion =  0
while not(posicion>=n):
    natural[posicion] = posicion
    posicion = posicion +1

# hipotesis todos cumplen
cumple = np.ones(n,dtype = int)

# Tarea: analiza cada posición
posicion = 2
# elimina multiplos / no cumplen
contador = 2
tacha  = posicion *contador
while not(tacha>(n-1)):
    tacha  = posicion *contador
    if tacha<(n-1):
        cumple[tacha] = 0
    contador = contador +1

# SALIDA
# solo valores de la posicion 2 en adelante
print(natural[2:])
print(cumple[2:])

mostrando el siguiente resultado:

cuantos numeros analiza: 50
[ 2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
 38 39 40 41 42 43 44 45 46 47 48 49]
[1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1]
>>> 

ejercicios resueltos Python 1eva_it2008_t2 pdf

ejercicios resueltos Matlab 1eva_it2008_t2 pdf

s1Eva_IT2008_T1 Teorema de Wilson

Ejercicio1Eva_IT2008_T1 Teorema de Wilson

Se usa el concepto de residuo de la división para determinar si el número es primo. La bandera usada es «esprimo» que inicia con el supuesto de ser verdadero ó 1.

Solo si el número resulta ser primo, se aplican las operaciones de Wilson

Instrucciones en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2008_T1 Teorema de Wilson

# INGRESO
n = int(input('ingrese numero primo: '))
while not(n>0):
    n = int(input('ingrese numero positivo: '))

# PROCEDIMIENTO

# revisa esprimo 
esprimo = 1
divisor = 2
while not(divisor>=n or esprimo==0):
    r = n%divisor
    if (r == 0):
        esprimo = 0
    divisor = divisor + 1

wilson = -1
if esprimo == 1:
    
    # factorial
    factor = 1
    i = 1
    while not(i>=n):
        factor = factor*i
        i = i + 1
    
    # revisa Wilson 
    residuo = (factor + 1) % n
    if residuo == 0:
        wilson = 1
    else:
        wilson = 0

# SALIDA
print('cumple Wilson: ', wilson)

resultado del algoritmo

ingrese numero primo: 7
cumple Wilson:  1
>>> 
== RESTART: D:\Ejemplos\unprograma.py ==
ingrese numero primo: 13
cumple Wilson:  1
>>> 
== RESTART: D:\Ejemplos\unprograma.py ==
ingrese numero primo: 8
cumple Wilson:  -1
>>> 

s1Eva_IIT2007_T3 Garantías de prestamos IESS

Ejercicio: 1Eva_IIT2007_T3 Garantías de prestamos IESS

Propuesta de solución en Pythonpy_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.

i reserva(i)
1 987
2 876
3 765
4 654
n
j cesantia(j)
1 876
2 765
3
..
m

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.

# 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

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

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

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

Diagrama de Flujo

ejercicios resueltos Python 1eva_iit2007_t3 pdf

ejercicios resueltos Matlab 1eva_iit2007_t3 pdf

s1Eva_IIT2007_T2 Juego de la Ruleta

Ejercicio: 1Eva_IIT2007_T2 Juego de la Ruleta

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

La simulación de la ruleta se realiza con la generación de un número entero aleatorio entre 1 y 37.

ruleta = int(rnd.random()*37)+1

Para desarrollar el ejercicio, inicie resolviendo para un solo jugador y un solo intento y mostrando si ganó o no.

Luego continúe incorporando la cantidad de intentos para un solo jugador,

Incorpore la petición de apuestas de los jugadores, antes de hacer rotar la ruleta en un arreglo o lista, para luego poder determinar los resultados de ganadores.

    # Ingreso de apuestas
    j = 1
    while (j<=n):
        print('jugador (',j,') ')
        apuesta[j] = int(input('  número apostado: '))
        j = j

Puede usar contadores para el número de veces ganó cada jugador en los m intentos.

Siguiendo el esquema anterior podrá resolver el ejercicio para todas las rondas con todos los jugadores.

Tarea: Completar el algoritmo para el número que salió la menor cantidad de veces.

Instrucciones en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2007_T2 Juego de la Ruleta
# Propuesta: edelros@espol.edu.ec

import numpy as np
import random as rnd

# INGRESO
n = int(input('¿cuántos jugadores?: '))
m = int(input('¿cuántas rondas?: '))

gana    = np.zeros(n+1, dtype=int)
apuesta = np.zeros(n+1, dtype=int)

ronda = 1
while (ronda<=m):

    # Ingreso de apuestas
    j = 1
    while (j<=n):
        print('jugador (',j,') ')
        apuesta[j] = int(input('  número apostado: '))
        j = j + 1

    ruleta = int(rnd.random()*37)+1
    print('Número ruleta: ', ruleta)

    # Revisa ganadores
    j = 1
    while (j<=n):
        if (ruleta==apuesta[j]):
            gana[j] = gana[j]+1   
        j = j + 1
         
    ronda = ronda + 1

# SALIDA
print('Los resultados son:')
j = 1
while (j<=n):
    print(' jugador(',j,') ganó ',gana[j],' veces \n')
    j = j + 1

Tarea: validar que el número de la apuesta esté en el tablero.

un ejemplo de ejecución:

cuantos jugadores: 2
cuantas rondas: 2
jugador ( 1 ) 
  número apostado: 3
jugador ( 2 ) 
  número apostado: 24
Número ruleta:  36
jugador ( 1 ) 
  número apostado: 34
jugador ( 2 ) 
  número apostado: 12
Número ruleta:  34
Los resultados son:
 jugador( 1 ) ganó  1  veces 

 jugador( 2 ) ganó  0  veces 

>>> 

Diagrama de Flujo

ejercicios resueltos Python 1eva_iit2007_t2 pdf

ejercicios resueltos Matlab 1eva_iit2007_t2 pdf

s1Eva_IIT2007_T1 Hormiga busca arroz

Ejercicio: 1Eva_IIT2007_T1 Hormiga busca arroz

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

Algoritmo con un paso  por cada turno

Considere ingresar la ubicación inicial (xh,yh) de la hormiga y que la posición del arroz (xa,ya) sea fija.

Suponga que la distancia inicial es la mayor y que la hormiga no ha encontrado el grano de arroz.

Para la dirección del movimiento de la hormiga y la cantidad de pasos se generan números aleatorios cuyos valores se usan para simular el movimiento al cambiar las coordenadas de la hormiga.

Luego de cada movimiento, se revisa si la hormiga encontró el grano de arroz o que las coordenadas sean iguales; también se puede revisar si la nueva distancia es mayor a las anteriores.

Cuente un turno completado, y repita el procedimiento hasta que se completen los 100 turnos o se haya encontrado el grano de arroz. Al final muestre los resultados buscados.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2007_T1 Hormiga busca arroz
import random as rnd

# INGRESO
xa=int(input(' x arroz: '))
ya=int(input(' y arroz: '))

xh=int(input(' x hormiga: '))
yh=int(input(' y hormiga: '))

# PROCEDIMIENTO
encontro = 0
t = 0
while not((xh==xa and yh==ya) or t>100):
    
    # dirección de movimiento de hormiga
    d = int(rnd.random()*4)+1
    
    if (d==1):
        yh = yh+1
    if (d==2):
        yh = yh-1
    if (d==3):
        xh = xh+1
    if (d==4):
        xh = xh-1

    # Revisa si lo encontró
    if (xh==xa and yh==ya):
        encontro = 1
    t = t + 1

print('¿encontró?: ')
print(encontro)
print('pasos realizados: ')
print(t)

Ejemplo de respuesta con el algoritmo

 x arroz: 5
 y arroz: 3
 x hormiga: 4
 y hormiga: 2
¿encontró?: 
1
pasos realizados: 
34
>>> 

 x arroz: 8
 y arroz: 8
 x hormiga: 3
 y hormiga: 2
¿encontró?: 
0
pasos realizados: 
101

Algoritmo con varios pasos por turno

En la solución con Python, se usarán las librerías básicas de aleatorios (random) y matemáticas (math).

Una alternativa a esta solución es usar la librería numérica NUMPY, que se descarga e instala como un módulo complementario.

Usando lazo Mientras-Repita:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1ra Eval II Termino 2007. Tema 1. Hormiga y arroz
# Propuesta de solución. edelros@espol.edu.ec

import random as rnd
import math

xh = int(input('coordenada x hormiga: '))
yh = int(input('coordenada y hormiga: '))

# PROCEDIMIENTO

# posición del arroz fija
xa = 10
ya = 8

# distancia inicial
dmayor = math.sqrt((xh-xa)**2+(yh-ya)**2)

encontrado = 0
turno = 0
while (turno<100 and encontrado==0):
    
    direccion = int(rnd.random()*4)+1
    pasos = int(rnd.random()*3)+1

    if direccion==1:
        yh = yh + pasos
    if direccion==2:
        yh = yh - pasos
    if direccion==3:
        xh = xh + pasos
    if direccion==4:
        xh = xh - pasos
        
    if (xh==xa and yh==ya):
        encontrado = 1

    distancia = math.sqrt((xh-xa)**2+(yh-ya)**2)
    if distancia>dmayor:
        dmayor = distancia
        
    turno = turno + 1

# SALIDA
print('estado encontrado: ')
print(encontrado)
print('turnos simulados: ')
print(turno)
print('distancia más lejana: ')
print(dmayor)

Reaultado del algoritmo:

coordenada x hormiga: 2
coordenada y hormiga: 1
estado encontrado: 
1
turnos simulados: 
92
distancia más lejana: 
23.323807579381203
>>> 
coordenada x hormiga: 0
coordenada y hormiga: 0
estado encontrado: 
0
turnos simulados: 
100
distancia más lejana: 
38.2099463490856
>>> 

Usando lazo Repita-Hasta:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1ra Eval II Termino 2007. Tema 1. Hormiga y arroz
# Propuesta de solución. edelros@espol.edu.ec

import random as rnd
import math

xh = int(input('coordenada x hormiga: '))
yh = int(input('coordenada y hormiga: '))

# PROCEDIMIENTO

# posición del arroz fija
xa = 10
ya = 8

# distancia inicial
dmayor = math.sqrt((xh-xa)**2+(yh-ya)**2)

encontrado = 0
turno = 0
while not(turno>=100 or encontrado!=0):
    
    direccion = int(rnd.random()*4)+1
    pasos = int(rnd.random()*3)+1
    
    if direccion==1:
        yh = yh + pasos
    if direccion==2:
        yh = yh - pasos
    if direccion==3:
        xh = xh + pasos
    if direccion==4:
        xh = xh - pasos
        
    if (xh==xa and yh==ya):
        encontrado = 1

    distancia = math.sqrt((xh-xa)**2+(yh-ya)**2)
    if distancia>dmayor:
        dmayor = distancia

    turno = turno+1

# SALIDA
print('estado encontrado: ')
print(encontrado)
print('turnos simulados: ')
print(turno)
print('distancia más lejana: ')
print(dmayor)

ejercicios resueltos Python 1eva_iit2007_t1 pdf

ejercicios resueltos Matlab 1eva_iit2007_t1 pdf

s1Eva_IT2007_T1 Tiro al blanco con dardos

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.

    x = (rnd.random()*160)-80
    y = (rnd.random()*160)-80

Se utiliza acumuladores de premios para cada franja de color, cuyo valor se determina mediante la comparación de la distancia del punto (x,y) al centro u origen del plano.

 d = math.sqrt(x**2+y**2)

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

Diagrama de Flujo Mientras-Repita

diagrama de flujo Tiro al blanco con dardos 01diagrama de flujo Tiro al blanco con dardos 02

 


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)

Diagrama de Flujo Repita-Hasta

diagrama de Flujo Tiro al blanco con dardos 03

diagrama de flujo Tiro al blanco con dardos 04

ejercicios resueltos Python 1eva_it2007_t1 pdf

ejercicios resueltos Matlab 1eva_it2007_t1 pdf

s1Eva_IIT2006_T2 Dígito verificador de cuenta

Ejercicio: 1Eva_IIT2006_T2 Dígito verificador de cuenta

Propuesta de solución en Python, otras propuestas : py_pdf, m_pdf

Para números de cuenta con 5 dígitos, se extrae el digito verificador usando el residuo para 10; con el cociente de la división para 10 queda el número de cuenta como se indica en la descripción. Referencia, Operaciones básicas

Ejemplo
Código: 25431 codigo = 25431
verificador escrito: 1 escrito = codigo%10
= 2543 % 10 = 1
número de cuenta: 2543 numero = codigo//10
= 25431 // 10 = 2543

se extraen los dígitos del número de posición impar usando también el residuo de 10. Se continua la operación con el siguiente dígito usando la división entera de 10

impar  = numero%10 = 2543%10 = 3
numero = numero//10 = 2543//10 = 254

de forma semejante se obtiene el dígito de posición par, usando el residuo de 10.

par = numero%10 =254%10 = 4
numero = numero//10 = 254//10 = 25

Se continúa con las operaciones para los siguientes dígitos, realizando la operación de suma y multiplicación.

Se obtiene el verificador calculado para compararlo con el verificador recibido, estableciendo si la respuesta es afirmativa o negativa.

Opción 1. Usando lazos, es más general para usar mayor cantidad de dígitos

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2006_T2 Dígito verificador de cuenta

# INGRESO
codigo = int(input('escriba el codigo completo: '))

# PROCEDIMIENTO
escrito = codigo%10
numero  = codigo//10

multimpar = 1
sumapar   = 0
while not(numero <= 0):
    impar  = numero%10
    numero = numero//10
    multimpar = multimpar*impar

    par = numero%10
    numero  = numero//10
    sumapar = sumapar+par
    
suma = sumapar + multimpar
calculado = suma%10

if (escrito == calculado):
    respuesta = 1
else:
    respuesta = 0

# SALIDA
print(respuesta)

Ejecución del algoritmo

escriba el codigo completo: 25431
1
>>> 
escriba el codigo completo: 25432
0
>>> 

Opción 2. En caso que requiera repasar más sobre lazos, aún se presenta una solución particular, solo para cuatro dígitos.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1ra Evaluación II Termino 2006
# Tema 2. Verificador cuenta. Ejercicio Básico

# INGRESO
codigo = int(input('escriba el codigo completo: '))

# PROCEDIMIENTO
escrito = codigo%10
numero = codigo//10

a = numero%10
numero = numero//10

b = numero%10
numero = numero//10

c = numero%10
d = numero//10

suma = a*c+(b+d)
calculado = suma%10

if (escrito == calculado):
    respuesta = 1
else:
    respuesta = 0

# SALIDA
print(respuesta)

ejercicios resueltos Python 1eva_iit2006_t2 pdf

ejercicios resueltos Matlab 1eva_iit2006_t2 pdf

s1Eva_IIT2005_T4 Juego escaleras y serpientes

Ejercicio: 1Eva_IIT2005_T4 Juego escaleras y serpientes

Propuesta de solución: python_pdf, matlab_pdf

En un primer bosquejo, no se considera el lanzar la moneda para ver cuál jugador inicia, semejante al ajedrez en que las fichas blancas salen primero sin considerar el nombre del jugador. escaleraserpiente

Para determinar las posiciones de las fichas en el tablero, se usarán acumuladores para cada jugador A y B, usando como variables “fichaa” y “fichab”.

 

# jugador A
dadoa = int(rnd.random()*6)+1
fichaa = fichaa + dadoa

Serán necesarios otras variables como el contador para el turno, cada jugador dispondrá de una variable generada de forma aleatoria que simula un dado de 6 caras.

Se lanza el dado para el jugador A, se avanza acumulando conforme a los puntos del dado, se valida el premio o castigo para luego repetir el proceso para el jugador B, repitiendo el proceso hasta que alguna ficha se ubique o pase la casilla de “llegada”.

Terminado el proceso anterior, se determina cuál jugador ganó, observe que se supone que gana tiene inicialmente el valor de 0, para tener la opción de registrar un empate.

Al final se muestran los resultados del juego simulado.

Tarea: Resolver con el lanzamiento de la moneda para ver cuál inicia.


Primero se presenta la solución usando lazo “Mientras-Repita” por compatibilidad con Matlab, luego se muestra la versión con el lazo “Repita-Hasta” que se puede escribir en los lenguajes de programación.

Instrucciones en Python. Versión Lazo: Mientras-Repita

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2005_T4 Juego escaleras y serpientes
# Propuesta de solución: edelros@espol.edu.ec

import random as rnd

# INGRESO
# Sortear quién empieza

# PROCEDIMIENTO
llegada = 64
fichaa = 0
fichab = 0

turno = 0
while (fichaa<llegada or fichab<llegada):

    # jugador A
    dadoa = int(rnd.random()*6)+1
    fichaa = fichaa + dadoa
    if (fichaa==4 or fichaa==9 or fichaa==29 or fichaa==34 or fichaa==46):
        fichaa = fichaa + 3
    if (fichaa==8 or fichaa==19 or fichaa==38 or fichaa==50 or fichaa==60):
        fichaa = fichaa - 3

    #jugador B
    dadob = int(rnd.random()*6)+1
    fichab = fichab + dadob
    if (fichab==4 or fichab==9 or fichab==29 or fichab==34 or fichab==46):
        fichab = fichab + 3
    if (fichab==8 or fichab==19 or fichab==38 or fichab==50 or fichab==60):
        fichab = fichab - 3

    turno = turno + 1

# Revisa ganador
gana = 0
if fichaa > fichab:
    gana = 1
if fichab > fichaa:
    gana = 2

# SALIDA
print('gana el jugador: ')
print(gana)
print('turnos jugados:')
print(turno)

Ejecución del algoritmo

gana el jugador: 
2
turnos jugados:
16
>>> 
gana el jugador: 
2
turnos jugados:
16
>>> 

Instrucciones en Python. Versión lazo: Repita-Hasta

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2005_T4 Juego escaleras y serpientes
# Propuesta de solución. edelros@espol.edu.ec

import random as rnd

# INGRESO
# Sortear quién empieza 
# PROCEDIMIENTO

llegada = 64
fichaa = 0
fichab = 0

turno = 0
while not(fichaa>=llegada or fichab>=llegada):

    # jugador A
    dadoa = int(rnd.random()*6)+1
    fichaa = fichaa+dadoa
    if (fichaa==4 or fichaa==9 or fichaa==29 or fichaa==34 or fichaa==46):
        fichaa = fichaa+3
    if (fichaa==8 or fichaa==19 or fichaa==38 or fichaa==50 or fichaa==60):
        fichaa = fichaa - 3

    #jugador B
    dadob = int(rnd.random()*6)+1
    fichab = fichab + dadob
    if (fichab==4 or fichab==9 or fichab==29 or fichab==34 or fichab==46):
        fichab = fichab + 3
    if (fichab==8 or fichab==19 or fichab==38 or fichab==50 or fichab==60):
        fichab = fichab - 3

    turno = turno+1

gana = 0
if fichaa>fichab:
    gana = 1

if fichab>fichaa:
    gana = 2

# SALIDA
print('gana el jugador: ')
print(gana)
print('turnos jugados:')
print(turno)

Diagrama de Flujo

 

ejercicios resueltos Python parc_iit2005_t4 pdf

ejercicios resueltos Matlab parc_iit2005_t4 pdf

s1Eva_IIT2005_T3 Entrenamiento atleta: promedios

Ejercicio: 1Eva_IIT2005_T3 Entrenamiento atleta: promedios

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

Ingresar todos los tiempos en un arreglo de n elementos.

# Inicia tabla de tiempos
tiempo = np.zeros((n+1),dtype=int)
dia = 1
while (dia<=n):
    print('tiempo[' + str(dia) + ']: ')
    tiempo[dia] = float(input(''))
    dia = dia + 1

Empezar con el promedio anual, acumular todos los tiempos y dividirlos para n.

# Promedio anual
s = 0
dia = 1
while (dia<=n):
    s = s + tiempo[dia]
    dia = dia+1
pranual = s/n

Para el promedio mensual, desarrollar el algoritmo para el primer mes (día 1 al 30) y luego revisar la relación que existe entre el primer día del mes y el número del mes, revisar también para el último día del mes.

Determinar la relación también para los días de la semana y el número de la semana, comparar resultados.

Tarea: completar el algoritmo, pues la solución propuesta no desarrolla el promedio semanal.

En el caso de Python, es necesario declarar el vector, al menos con valores de 0. Como la primera posición del arreglo es 0 y no existe el día 0, se aumentará el tamaño del vector en 1, a fin de usar el indicador de día de forma más natural.

Se requiere importar la librería numpy, para trabajar con los arreglos.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2005_T3 Entrenamiento atleta: promedios
# Propuesta de solución. edelros@espol.edu.ec
# Tarea: realizar promedio por semana

import numpy as np

# INGRESO
n = int(input('¿días a cronometrar?: '))

# Inicia tabla de tiempos
tiempo = np.zeros((n+1),dtype=int)
dia = 1
while (dia<=n):
    print('tiempo[' + str(dia) + ']: ')
    tiempo[dia] = float(input(''))
    dia = dia + 1

# PROCEDIMIENTO

# Promedio anual
s = 0
dia = 1
while (dia<=n):
    s = s + tiempo[dia]
    dia = dia+1
pranual = s/n

# Promedio mensual
mes = 1
maxmes = int(n/30)
while (mes<=maxmes):
    s = 0
    dia = 1+30*(mes-1)
    while (dia<=(30*mes)):
        s = s+tiempo[dia]
        dia = dia+1
    prm[mes] = s/30
    mes = mes+1

# SALIDA
print('Promedio anual: ')
print(pranual)
print('Promedio mensual: ')
mes = 1
if maxmes==0:
    print('Meses completos: 0')
while (mes<=maxmes):
    print(prm[mes])
    mes = mes+1

# Se modificó el algoritmo para
# probar con n de pocos días.

Ejecución del algoritmo

¿días a cronometrar?: 5
tiempo[1]: 
20
tiempo[2]: 
18
tiempo[3]: 
23
tiempo[4]: 
19
tiempo[5]: 
22
Promedio anual: 
20.4
Promedio mensual: 
Meses completos: 0
>>> 

Diagrama de Flujo

ejercicios resueltos Python parc_iit2005_t3 pdf

ejercicios resueltos Matlab parc_iit2005_t3 pdf

s1Eva_IIT2005_T2 Negocio piramidal

Ejercicio: 1Eva_IIT2005_T2 Negocio piramidal

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

Para la solución, considere las operaciones descritas en el orden lógico de ejecución:
 depósitos, comisiones e intereses para calcular el saldo.

El control de participantes e invitados permitirá calcular apropiadamente los depósitos de los invitados y los intereses pagados a los participantes.

deposito = invitado*x
comision = 0.20*deposito
interespaga = 0.10*x*participa
saldo = saldo+deposito-comision-interespaga
participa = participa+invitado

Los meses se cuentan para cada iteración hasta que se cumpla la condición que los intereses pagados sean mayores al saldo.

Algoritmo en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2005_T2 Negocio piramidal
# Propuesta de solución: edelros@espol.edu.ec

# INGRESO
x = int(input('cantidad por depositante: '))
n = int(input('personas en el mercado: '))

# PROCEDIMIENTO
mes = 0
invitado = 1
participa = 0

saldo = 0
interespaga = 0
while (interespaga<=saldo):
    deposito = invitado*x
    comision = 0.20*deposito
    interespaga = 0.10*x*participa
    saldo = saldo+deposito-comision-interespaga
    participa = participa+invitado

    if (participa<=(n/2)):
        invitado = participa
    else:
        invitado = 0
    
    mes = mes+1

# SALIDA
print('meses con saldo disponible: ')
print(mes)

Ejecución del algoritmo

cantidad por depositante: 100
personas en el mercado: 1000
meses con saldo disponible: 
17
>>>

Diagrama de Flujo


ejercicios resueltos Python parc_iit2005_t2 py_pdf

ejercicios resueltos Matlab parc_iit2005_t2 pdf