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 vacío.

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.

Algoritmo 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

Algoritmo en Python

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

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

Algoritmo en Python

# 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

Ejercicio: 3Eva_IT2003_T1 Raíces enteras positivas del polinomio

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

El problema se separa en sus partes principales.
Primero la función para encontrar las raíces enteras, usando un contador que
aumenta cuando encuentra que el polinomio evaluado en x tienen valor de 0.

En el programa, para ingresar el polinomio se almacenan solo los coeficientes,
el término i-ésimo también indica el exponente de coeficiente[i]*xi.

Nota: No se incluye la forma de realizar la gráfica en la solución presentara
para el examen.

Algoritmo en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IT2003_T1 Raíces enteras positivas del polinomio
# propuesta de solución: edelros@espol.edu.ec

import numpy as np

def numraices(grado,coeficiente,a,b):
    encontre=0
    x = a
    while (x<=b):
        p = 0
        i = 0
        while (i<=grado):
            p = p + coeficiente[i]*(x**i)
            i = i + 1
        if (p==0):
            encontre = encontre+1
        x = x + 1
    return (encontre)

# PROGRAMA -----------------

# INGRESO
n = int(input("grado polinomio: "))
coeficiente = np.zeros(n+1,dtype=float)
for i in range(0,n+1,1):
    coeficiente[i] = float(input("coeficiente["+str(i)+"]: "))
print("Rango de busqueda: [a,b]")
a = int(input("a: "))
b = int(input("b: "))

# PROCEDIMIENTO
resultado = numraices(n,coeficiente,a,b)

# SALIDA
print("numero de raices enteras:")
print(resultado)

resultado del algoritmo

grado polinomio: 7
coeficiente[0]: 0
coeficiente[1]: -336
coeficiente[2]: 356
coeficiente[3]: 208
coeficiente[4]: -337
coeficiente[5]: 127
coeficiente[6]: 19
coeficiente[7]: 1
Rango de busqueda: [a,b]
a: -10
b: 40
numero de raices enteras:
1
>>> 

ejercicios resueltos Python mejo_it2003_t1 pdf

ejercicios resueltos Matlab mejo_it2003_t1 pdf

Ejercicio: 3Eva_IT2002_T3 Determinar productos iguales entre vendedores

Se usan listas de prueba para desarrollar el algoritmo, siendo:

vendedor1 = ['pera','manzana','uva']
vendedor2 = ['durazno','pera','naranja']

se obtiene:

ambos venden:
pera
>>> 

Tarea: Desarrollar el literal a, usando archivos.

Algoritmo en Python

# 3Eva_IT2002_T3 Determinar productos iguales entre vendedores
# desarrollo con listas, solo literal b
# Tarea, desarrollar literal a

# INGRESO
vendedor1 = ['pera','manzana','uva']
vendedor2 = ['durazno','pera','naranja']

# PROCEDIMIENTO
n = len(vendedor1)
m = len(vendedor2)
ambos = []
for i in range(0,n,1):
    for j in range(0,m,1):
        if vendedor1[i] == vendedor2[j]:
            ambos.append(i)

# SALIDA
w = len(ambos)
print('ambos venden:')
for k in range(0,w,1):
    cual = ambos[k]
    print(vendedor1[cual])

Ejercicio: 3Eva_IT2002_T1 Triunfos, empates y derrotas por Goles

Instrucciones en Python

explicación en video:

Algoritmo en Python

# 3Eva_IT2002_T1 Triunfos, empates y derrotas por Goles
import numpy as np

# INGRESO
goles = np.array([[0,4,2,1],
                  [5,0,3,2],
                  [0,2,0,1],
                  [1,0,2,0]])

# PROCEDIMIENTO
tamano = np.shape(goles)
n = tamano[0]
m = tamano[1]
triunfos = np.zeros(shape=(n,m),dtype=int)
ttriunfos = np.zeros(n,dtype=int)
# calcular los triunfos
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        if (goles[i,j] > goles[j,i]):
            triunfos[i,j] = 1
            triunfos[j,i] = 0
        j = j + 1
    i = i + 1
# calcular total de triunfos
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        ttriunfos[i] = ttriunfos[i] + triunfos[i,j]
        j = j + 1
    i = i + 1

# calcular empates
empates = np.zeros(shape=(n,m),dtype=int)
tempates = np.zeros(n,dtype=int)
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        if (goles[i,j] == goles[j,i]) and (i!=j):
            empates[i,j] = 1
            empates[j,i] = 1
        j = j + 1
    i = i + 1
# calcular total de empates
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        tempates[i] = tempates[i] + empates[i,j]
        j = j + 1
    i = i + 1

# Derrotas
derrotas = (n-1)*np.ones(n,dtype=int)
derrotas = derrotas - ttriunfos - tempates

# SALIDA
print(triunfos)
print(' triunfos por equipo: ')
print(ttriunfos)
print(empates)
print(' empates por equipo:')
print(tempates)
print(' derrotas por equipo:')
print(derrotas)

Ejercicio: 3Eva_IT2000_T2 Matriz: puntos por goles en campeonato

Desarrollado en Python a partir el ejercicio 3Eva_IT2002_T1 Triunfos, empates y derrotas por Golesf

goles=np.array([[0, 3, 1, 2, 1],
                [1, 0, 3, 2, 3],
                [0, 2, 0, 1, 1],
                [1, 0, 2, 0, 1],
                [3, 4, 1, 2, 0]])

complementando la solución del ejercicio de triunfos empates y derrotas se obtiene para los datos ingresados:

 triunfos por equipo: 
[3 2 0 1 3]
 empates por equipo:
[0 0 1 0 1]
 derrotas por equipo:
[1 2 3 3 0]
puntos por equipo:
[ 9  6  1  3 10]
>>> 

Algoritmo en Python

# 3Eva_IT2000_T2 Matriz: puntos por goles en campeonato
import numpy as np

# INGRESO
goles=np.array([[0, 3, 1, 2, 1],
                [1, 0, 3, 2, 3],
                [0, 2, 0, 1, 1],
                [1, 0, 2, 0, 1],
                [3, 4, 1, 2, 0]])

# PROCEDIMIENTO
tamano = np.shape(goles)
n = tamano[0]
m = tamano[1]
triunfos = np.zeros(shape=(n,m),dtype=int)
ttriunfos = np.zeros(n,dtype=int)
# calcular los triunfos
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        if (goles[i,j] > goles[j,i]):
            triunfos[i,j] = 1
            triunfos[j,i] = 0
        j = j + 1
    i = i + 1
# calcular total de triunfos
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        ttriunfos[i] = ttriunfos[i] + triunfos[i,j]
        j = j + 1
    i = i + 1

# calcular empates
empates = np.zeros(shape=(n,m),dtype=int)
tempates = np.zeros(n,dtype=int)
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        if (goles[i,j] == goles[j,i]) and (i!=j):
            empates[i,j] = 1
            empates[j,i] = 1
        j = j + 1
    i = i + 1
# calcular total de empates
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        tempates[i] = tempates[i] + empates[i,j]
        j = j + 1
    i = i + 1

# Derrotas
derrotas = (n-1)*np.ones(n,dtype=int)
derrotas = derrotas - ttriunfos - tempates

# puntos totales
puntos_triunfos = ttriunfos*3
puntos_empates  = tempates*1
puntos = puntos_triunfos+puntos_empates 

# SALIDA
print(triunfos)
print(' triunfos por equipo: ')
print(ttriunfos)
print(' empates por equipo:')
print(tempates)
print(' derrotas por equipo:')
print(derrotas)
print('puntos por equipo:')
print(puntos)