s3Eva_IIIT2003_T4 Informes notas de estudiantes

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

s3Eva_IIIT2003_T2 Socios del club por género

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

s3Eva_IIIT2003_T1 Funciones lógicas pyq y poq

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

s3Eva_IT2003_T5 Calcular área de f(x) por Montecarlo

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

s3Eva_IT2003_T3 Reportar notas desde un archivo

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

s3Eva_IT2003_T2 Verificar un cuadrado mágico

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

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

s3Eva_IT2003_T1 Raíces enteras positivas del polinomio

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

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

s3Eva_IT2002_T3 Determinar productos iguales entre vendedores

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.

Intrucciones 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])

s3Eva_IT2002_T1 Triunfos, empates y derrotas por Goles

Ejercicio: 3Eva_IT2002_T1 Triunfos, empates y derrotas por Goles

Instrucciones en Python

explicación en video:

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

s3Eva_IT2000_T2 Matriz: puntos por goles en campeonato

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 Goles

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

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