Etiqueta: fundamentos programacion

Ejercicio: 3Eva_IIIT2004_T1 Carrera de ranas

Resultados esperados:

longitud de la pista: 20
ganador:  A
saltos:  16
>>> 

longitud de la pista: 20
ganador:  B
saltos:  23
>>> 

Instrucciones Python

# 3Eva_IIIT2004_T1 Carrera de ranas
import random as rnd

# INGRESO
n = int(input('longitud de la pista: '))

# PROCEDIMIENTO
A = 0
B = 0 
turno = 0
gana = ''
while gana=='':
    saltoA = int(rnd.random()*3)+0
    saltoB = int(rnd.random()*3)+0
    A = A + saltoA
    B = B + saltoB
    turno = turno + 1
    if A>n:
        gana = 'A'
    if B>n:
        gana = 'B'

# SALIDA
print('ganador: ', gana)
print('saltos: ',turno)

Tarea: Considere que los turnos de saltos no corresponden a los saltos de cada rana, observe cuando se queda en el mismo puesto, no es un salto.

Ejercicio: 3Eva_IT2004_T3 Multiplicar con campesino egipcio

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

Literal a. La función en forma recursiva considera cuatro casos para q y el residuo de q con 2. Usar un condicional en cada caso siguiendo lo descrito en la fórmula.

mult(p,q) = \begin {cases} 0 , && q=0 \\ p ,&& q=1 \\ mult \Big(2p,cociente\big(\frac{q}{2}\big)\Big) , && q\ge 2 \text {, q es par} \\ mult \Big(2p,cociente\big(\frac{q}{2}\big)\Big)+p , && q\ge 2 \text{, q es impar }\end{cases}

Literal b.  Requiere que sea un programa estructurado, separando las partes de las funciones de usuario y el programa que lo usa.

En el bloque de ingreso del programa se pide cuál tabla de multiplicar se va a generar. Se require que la tabla se genere usando la función creada en el literal a.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IT2004_T3 Multiplicar con campesino egipcio
# propuesta: edelros@espol.edu.ec

def mult(p,q):
    if q==0:
        z = 0
    if q==1:
        z = p
    r = (q%2)
    if (q>=2 and r==0):
        z = mult(2*p, int(q/2))
    if (q>=2 and r>0):
        z = mult(2*p, int(q/2))+p
    return (z)

# PROGRAMA ---------------
import numpy as np

# INGRESO
n = int(input('¿cual tabla?: '))

# PROCEDIMIENTO
r = np.zeros(13,dtype=int)
i = 1
while (i<=12):
    r[i] = mult(n,i)
    i = i + 1

# SALIDA
i=1
while (i<=12):
    print(str(n)+' x '+str(i)+' = ',str(r[i]))
    i = i + 1

Tarea: validar n entre cero y 12

resultado del algoritmo

¿cual tabla?: 8
8 x 1 =  8
8 x 2 =  16
8 x 3 =  24
8 x 4 =  32
8 x 5 =  40
8 x 6 =  48
8 x 7 =  56
8 x 8 =  64
8 x 9 =  72
8 x 10 =  80
8 x 11 =  88
8 x 12 =  96
>>> 

ejercicios resueltos Python mejo_it2004_t3 pdf

ejercicios resueltos Matlab mejo_it2004_t3 pdf

Ejercicio: 3Eva_IT2004_T2 Realizar el producto vectorial

resultado obtenido

[-1, 2, 7]
>>> 

Instrucciones en Python

# 3Eva_IT2004_T2 Realizar el producto vectorial

# INGRESO
A = [1,3,1]
B = [-2,1,0]

# PROCEDIMIENTO
c0 = A[1]*B[2]-B[1]*A[2]
c1 = A[0]*B[2]-B[0]*A[2]
c2 = A[0]*B[1]-B[0]*A[1]

C = [c0,c1,c2]

# SALIDA
print(C)

Ejercicio: 3Eva_IT2004_T1 Buscar número al lanzar el dado

resultado para la función del enunciado

>>> al_fin(2,7)
2
>>> al_fin(2,7)
12
>>> al_fin(2,7)
5
>>> 

Tarea, realizar el programa requerido en el enunciado usando la función al_fin(n,k)

Instrucciones Python

# 3Eva_IT2004_T1 Buscar número al lanzar el dado
import random as rnd

def al_fin(n,k):
    veces = 0
    exitos = 0
    while exitos == 0:
        aleatorio = int(rnd.random()*6)+1
        if aleatorio == n:
            exitos = exitos+1
        veces = veces + 1
    return(veces) 

# Tarea, realizar el programa requerido

Ejercicio: 3Eva_IIIT2003_T4 Informes notas de estudiantes

Propuesta de solución en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IIIT2003_T4 Informes notas de estudiantes

# INGRESO
estudiantes = []
n = int(input('cupo: '))
i = 0
while not(i>=n):
    nom = input('nombre: ')
    eda = int(input('edad: '))
    gen = input(' genero m/f: ')
    while not(gen=='f' or gen=='m'):
        print(' genero f o m ')
        gen = input('genero: ')
    
    par = int(input('parcial: '))
    while not(par>=0 and par<=100):
        print(' nota son [0,100] ')
        par = int(input('parcial: '))
        
    fin = int(input('final: '))
    while not(fin>=0 and fin<=100):
        print(' nota son [0,100] ')
        fin = int(input('final: '))
        
    registro = {'nombre':nom,
                'edad':eda,
                'genero':gen,
                'parcial':par,
                'final':fin}
    estudiantes.append(registro)
    i = i+1

# ingresa sin extension '.txt'
narchivo = input('nombre del archivo: ')
narchivo = narchivo + '.txt'

# PROCEDIMIENTO
# Guarda el archivo con datos estudiantes
n =  len(estudiantes)
archivo = open(narchivo, 'w')
i = 0
while not(i>=n):
    nom = estudiantes[i]['nombre']
    eda = estudiantes[i]['edad']
    gen = estudiantes[i]['genero']
    par = estudiantes[i]['parcial']
    fin = estudiantes[i]['final']
    linea = nom +','+str(eda)+','+gen
    linea = linea + ',' + str(par)
    linea = linea + ',' + str(fin) + '\n'
    archivo.write(linea)
    i = i + 1

archivo.close()

# SALIDA
print(estudiantes)

resultado del algoritmo

upo: 5
nombre: Juan
edad: 19
 genero m/f: m
parcial: 65
final: 40
nombre: Maria
edad: 18
 genero m/f: f
parcial: 70
final: 80
nombre: Ana
edad: 19
 genero m/f: f
parcial: 90
final: 92
nombre: Juan
edad: 20
 genero m/f: m
parcial: 40
final: 80
nombre: Rosa
edad: 18
 genero m/f: f
parcial: 80
final: 85
nombre del archivo: calificaciones
[{'nombre': 'Juan', 'edad': 19, 'genero': 'm',
  'parcial': 65, 'final': 40},
 {'nombre': 'Maria', 'edad': 18, 'genero': 'f',
  'parcial': 70, 'final': 80},
 {'nombre': 'Ana', 'edad': 19, 'genero': 'f',
  'parcial': 90, 'final': 92},
 {'nombre': 'Juan', 'edad': 20, 'genero': 'm',
  'parcial': 40, 'final': 80},
 {'nombre': 'Rosa', 'edad': 18, 'genero': 'f',
  'parcial': 80, 'final': 85}]
>>> 

Ejercicio: 3Eva_IIIT2003_T2 Separar lista socios club por género

Para el ingreso de datos se inicializan tres listas en vacio.

nombre = [] 
genero = [] 
edad = []

Se preguntan datos que se añaden a cada lista, siempre que la bandera finalizado sea cero.

Tarea por realizar en el bloque de ingreso: validar el género ingresado ‘m’ o ‘f’

La selección de datos se realiza en un bloque de procedimiento, revisando la lista de género. Con la variable género se añaden los nombres a las listas que correspondan a hombres o mujeres.

El resultado se muestra en pantalla.

Instrucciones en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IIIT2003_T2 Separar lista socios club por género

# INGRESO
nombre = []
genero = []
edad   = []
finalizado = 0
while (finalizado == 0):
    unnombre = input('un nombre:  ')
    ungenero = input('genero M/F: ')
    unaedad =  int(input('edad:   '))
    finalizado = int(input('finalizar 0/1:'))

    # añade datos a la lista
    nombre.append(unnombre)
    genero.append(ungenero)
    edad.append(unaedad)

# PROCEDIMIENTO
n = len(nombre)
hombres = []
mujeres = []
i = 0
while not(i>=n):
    if (genero[i]=='M'):
        hombres.append(nombre[i])
    if (genero[i]=='F'):
        mujeres.append(nombre[i])
    i = i + 1

# SALIDA
print('hombres: ',hombres)
print('mujeres: ',mujeres)

resultado del algoritmo

un nombre:  Maria
genero M/F: F
edad:   18
finalizar 0/1:0
un nombre:  Pedro
genero M/F: M
edad:   19
finalizar 0/1:0
un nombre:  Ana
genero M/F: F
edad:   19
finalizar 0/1:0
un nombre:  Juan
genero M/F: M
edad:   20
finalizar 0/1:1
hombres:  ['Pedro', 'Juan']
mujeres:  ['Maria', 'Ana']
>>> 

Ejercicio: 3Eva_IIIT2003_T1 Funciones lógicas pyq y poq

Propuesta de solución en Python, se desarrollan dos partes: funciones y programa

Las funciones se incorporan al bloque de inicio.
El programa sigue los bloques de ingreso, procedimiento y salida

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IIIT2003_T1 Funciones lógicas pyq y poq

def pyq(p,q):
    
    # validar
    resultado = -1
    if (p==0 or p==1):
        if (q==0 or q==1):
            resultado = p*q
    return(resultado)

def poq(p,q):
    
    # validar
    resultado = -1
    if (p==0 or p==1):
        if (q==0 or q==1):
            resultado = p+q
            if resultado>1:
                resultado = 1
    return(resultado)

# PROGRAMA

# INGRESO
p = int(input('p: '))
q = int(input('q: '))

# PROCEDIMIENTO
respuesta1 = poq(pyq(p,q), pyq(p,q))
respuesta2 = poq(p, pyq(p,q))

# SALIDA
print('(p ∧ q) ∨ (p ∧ q): ', respuesta1)
print('p ∨ (p ∧ q): ', respuesta2)

resultado del algoritmo

p: 1
q: 1
(p ∧ q) ∨ (p ∧ q):  1
p ∨ (p ∧ q):  1
>>> 
p: 1
q: 0
(p ∧ q) ∨ (p ∧ q):  0
p ∨ (p ∧ q):  1
>>> 
p: 0
q: 1
(p ∧ q) ∨ (p ∧ q):  0
p ∨ (p ∧ q):  0
>>> 

Ejercicio: 3Eva_IT2003_T5 Calcular área de f(x) por Montecarlo

La forma gráfica del ejercicio permite comprender mejor lo que se estima.

Se generan puntos de posiciones aleatorias xi, yi dentro del cuadro limitado por [a,b] en x , [x,d] en y.

Para cada valor de x aleatorio, se evalua en la función f(x), observando si el valor de y aleatorio esta por encima o debajo de la función.

Se estima que la proporción de puntos debajo de f(x) del total de puntos es proporcional al área del rectángulo.

El resultado del algoritmo para un experimento con n = 50 es:

Area estimada:  0.68

Area estimada:  0.62

Se intuye que la precisión mejora al usar n mucho mas grande.

Instrucciones en Python

# 3Eva_IT2003_T5 Calcular área de f(x) por Montecarlo
import numpy as np
import random as rnd
import matplotlib.pyplot as plt

# INGRESO
n = 50 # puntos aleatorios
a = 1
b = 2
fx = lambda x: x*np.exp(-x/2)

c = 0
d = 1 # actualizar a max(fx(xi))

# PROCEDIMIENTO
xi = []
yi = []
fi = []
bajofx  = 0
for i in range(0,n,1):
    # genera puntos aleatorios
    unxi = rnd.random()*(b-a)+a
    unyi = rnd.random()*(d-c)+c
    fxi = fx(unxi)
    
    # debajo de fx()
    if unyi<=fxi:
        bajofx = bajofx +1

    # guarda los puntos
    xi.append(unxi)
    yi.append(unyi)
    fi.append(fxi)

# estima area
Arectangulo = (b-a)*(d-c)
Aestimada = Arectangulo*bajofx/n

# SALIDA
print('Area estimada: ', Aestimada)

# grafica
plt.scatter(xi,yi, label = 'aleatorios')
plt.scatter(xi,fi, label = 'f(x)')
plt.xlabel('xi')
plt.ylabel('yi')
plt.legend()
plt.show()

Ejercicio: 3Eva_IT2003_T3 Reportar notas desde un archivo

Propuesta de solución en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IT2003_T3 Reportar notas desde un archivo
# Usando un menu para cada accion

n = 0 # Sin notas

opcion = '0'
while not(opcion=='4'):
    print('1. Ingresar notas y Guardar archivo')
    print('2. Abrir archivo de notas')
    print('3. Calcular promedio y Guardar archivo notasfinal')
    print('4. Salir')
    
    opcion = input(' -- cual opcion: ')

    if (opcion=='1'):
        # Ingresar datos
        nota = []
        n = int(input('cuantos estudiantes: '))
        for i in range(0,n,1):
            matricula = input('matricula: ')
            apellido = input('apellido: ')
            nota1 = int(input('nota1 : '))
            nota2 = int(input('nota2 : '))
            nota.append([matricula,apellido,nota1,nota2])

        # Crear archivo 'notas.txt' datos separados por ','
        archivo = open('notas.txt','w')
        for i in range(0,n,1):
            linea = nota[i][0]+','+nota[i][1]+','
            linea = linea +str(nota[i][2])+','+str(nota[i][3])+'\n'
            archivo.write(linea)
            
        print('archivo almacenado')
        archivo.close()
        
    if (opcion=='2'):
        # Abrir archivo de notas
        nota = []
        archivo = open('notas.txt','r')
        linea = archivo.readline()
        
        #leer por linea hasta final ''
        while not(linea==''): 
            # Separa y convierte tipo de datos
            dato = linea.split(',')
            matricula = dato[0]
            apellido  = dato[1]
            nota1 = int(dato[2])
            nota2 = int(dato[3])
            nota.append([matricula,apellido,nota1,nota2])

            # Lee la siguiente linea
            linea = archivo.readline()
        archivo.close()
        print('Datos leidos desde archivo')
        print(nota)

    if (opcion=='3'):
        # Calcula promedio
        n = len(nota)
        promedio = []
        for i in range(0,n,1):
            prm = float((nota[i][2]+nota[i][3])/2)
            promedio.append([prm])
        # Crear archivo 'final.txt' datos separados por ','
        archivo = open('final.txt','w')
        for i in range(0,n,1):
            linea = nota[i][0]+','+nota[i][1]
            linea = linea +','+str(promedio[i])+'\n'
            archivo.write(linea)
        print('archivo almacenado')
        archivo.close()
        
    if (opcion=='4'):
        print('Mejoramiento I Término 2003, Tema 3')
        print('icm00794 Fundamentos de computacion')

Ejercicio: 3Eva_IT2003_T2 Verificar un cuadrado mágico

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

El problema se separa en sus partes principales.

Primero se revisa el número de veces que aparece cada número en el cuadrado. Luego se suma cada fila y columna, guardando los resultados en vectores.

La suma de las diagonales se las hace aparte pues solo se necesita mover un índice; la diagonal principal tiene el mismo índice en la fila y columna; y la diagonal segundaria, en cambio la columna es decreciente.

Se validan los resultados parciales con las condiciones para que sea mágico y se muestra el resultado

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IT2003_T2 Verificar un cuadrado mágico
# Propuesta: edelros@espol.edu.ec

import numpy as np

# INGRESO
n = int(input("tamaño cuadrado: "))

while (n>10):
    n = int(input("tamaño cuadrado(n<10): "))

cuadrado = np.zeros(shape=(n,n),dtype=int)
for i in range(0,n,1):
    for j in range(0,n,1):
        cuadrado[i,j] = input("cuadrado ["+str(i+1)+","+str(j+1)+"]: ")

# PROCEDIMIENTO
# verifica numeros repetidos
m = n*n
repetido = np.zeros(m+1,dtype=int)
masdeuno = 0
for i in range(0,n,1):
    for j in range(0,n,1):
        k = cuadrado[i,j]
        repetido[k]=repetido[k]+1
        if (repetido[k]>1):
            masdeuno = k
            
#suma de filas y columnas
sfila = np.zeros(n,dtype=int)
scolumna = np.zeros(n,dtype=int)
for i in range(0,n,1):
    for j in range(0,n,1):
        sfila[i] = sfila[i] + cuadrado[i,j]
        scolumna[i] = scolumna[i] + cuadrado[j,i]
        
# Suma diagonales
sdiagonal  = 0
sdiagonal2 = 0
for i in range(0,n,1):
    sdiagonal  = sdiagonal + cuadrado[i,i]
    sdiagonal2 = sdiagonal2 + cuadrado[i,n-1-i]

# verifica condiciones magico
magico = 1
if (masdeuno>0):
    magico = 0
if not(sdiagonal==sdiagonal2):
    magico = 0
for i in range(0,n,1):
    if not(sdiagonal==sfila[i]):
        magico = 0
    if not(sdiagonal==scolumna[i]):
        magico = 0

# SALIDA
print("El resultado es:")
print(magico)

resultado del algoritmo

tamaño cuadrado: 3
cuadrado [1,1]: 4
cuadrado [1,2]: 9
cuadrado [1,3]: 2
cuadrado [2,1]: 3
cuadrado [2,2]: 5
cuadrado [2,3]: 7
cuadrado [3,1]: 8
cuadrado [3,2]: 1
cuadrado [3,3]: 6
El resultado es:
1
>>> 

ejercicios resueltos Python mejo_it2003_t2 pdf

ejercicios resueltos Matlab mejo_it2003_t2 pdf