Categoría: Sol_2Eva 2001-2002-2003

Ejercicio: 2Eva_IIIT2003_T3 Distancia de Hamming

Primero se plantea un algoritmo para determinar el número de parejas diferentes que existen dentro de cada cadena:

propuesta de solución en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIIT2003_T3 Distancia de Hamming

# INGRESO
U = '20001'
V = '10103'


# PROCEDIMIENTO
n = len(U)
m = len(V)

respuesta = -1
if n == m:
    diferente = 0
    i = 0
    while not(i>=n):
        if U[i] != V[i]:
            diferente = diferente +1
        i = i + 1
# SALIDA
print('distancia Hamming: ', diferente)

resultado del algoritmo

distancia Hamming:  3
>>> 

Luego se procede a convertir el algoritmo a una función y hacer la llamada desde un programa, con lo que se cumple lo requerido en cada literal

Algoritmo en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIIT2003_T3 Distancia de Hamming

# literal a. funcion
def dHamming(U,V):
    n = len(U)
    m = len(V)

    respuesta = -1
    if n == m:
        diferente = 0
        i = 0
        while not(i>=n):
            if U[i] != V[i]:
                diferente = diferente +1
            i = i + 1
    return(diferente)

# Programa -------------
# INGRESO
U = '20001'
V = '10103'

# PROCEDIMIENTO
diferente = dHamming(U,V)

# SALIDA
print('distancia Hamming: ', diferente)

Tarea: Añadir la lectura de los datos desde un archivo.

Ejercicio: 2Eva_IIIT2003_T2 Raíz cuadrada por Newton

Empezando con el valor de x:

f(1) = \frac{x}{2}

Se usa la expresión recursiva:

f(n) = 0.5\Bigg(f(n-1) + \frac{x}{f(n-1)}\Bigg)

Los valores tabulados para x=9 y n=10

ingrese x: 9
aproximación n-esima: 10
 i , f(i)
0 nan
1 4.5
2 3.25
3 3.0096153846153846
4 3.000015360039322
5 3.0000000000393214
6 3.0
7 3.0
8 3.0
9 3.0
10 3.0
>>> 

y para x= 9.5 con x=10

ingrese x: 9.5
aproximación n-esima: 10
 i , f(i)
0 nan
1 4.75
2 3.375
3 3.0949074074074074
4 3.082233060472589
5 3.0822070015946474
6 3.0822070014844885
7 3.0822070014844885
8 3.0822070014844885
9 3.0822070014844885
10 3.0822070014844885
>>> 

---

Instrucciones en Python

# 2Eva_IIIT2003_T2 Raíz cuadrada por Newton
import numpy as np

# literal a. función recursiva
def raizNewton(x,n):
    if n<=0 or x<=0:
        f = np.NaN
    else:
        if n == 1:
            f = x/2
        if n>1:
            f = 0.5 *(raizNewton(x,n-1)+x/raizNewton(x,n-1))
    return (f)

# literal b. Programa ---------------
# INGRESO
x = float(input('ingrese x: '))
n = int(input('aproximación n-esima: '))

# PROCEDIMIENTO
print(' i , f(i)')
for i in range(0,n+1,1):
    print(i , raizNewton(x,i))

Ejercicio: 2Eva_IIT2001_T2 Contar puntos aleatorios en un triángulo

Se cuentan los puntos que caen el el área marcada en verde que se encuentra debajo de:

f(x)= -x+10

siendo el intervalo [a,b] con valores de a = 0 y b=10, la mitad corresponde a  (a+b)/2

Como las áreas consideradas corresponden a dos sectores, considere usar x entre[a,mitad] y entre [mitad, b], limitados en y por la línea f(x)

Un resultado gráfico, no requerido para el ejercicio, tan solo para mejor comprensión:

de n puntos:  100
 dentro estaban:  25
>>> 

Intrucciones en Python

# 2Eva_IIT2001_T2 Contar puntos aleatorios en un triángulo
import random as rnd
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
n = 100
a = 0
b = 10

f = lambda x: -x+10

# PROCEDIMIENTO
mitad = (a+b)/2
X = []
Y =[]
dentro = 0
i = 0
while not(i>=n):
    xi = rnd.random()*(b-a)+0
    yi = rnd.random()*(b-a)+0
    limite = f(xi)
    if xi>mitad and yi<=limite:
        dentro = dentro +1
    if xi<=mitad and yi<=limite and yi>=mitad:
        dentro = dentro +1
    X.append(xi)
    Y.append(yi)
    i = i+1

# SALIDA
print(' de n puntos: ', n)
print(' dentro estaban: ', dentro)


# Grafica
plt.scatter(X,Y)
xi = np.linspace(a,b,n+1)
plt.plot(xi,f(xi))
plt.axhline(mitad)
plt.axvline(mitad)
plt.xlim(a,b)
plt.ylim(a,b)
plt.xlabel('xi')
plt.ylabel('yi')
plt.show()

Ejercicio: 2Eva_IIT2003_T2 Mostrar un triángulo de Pascal

Para crear la matriz de Pascal en Python se usa la librería Numpy, con lo que se crea un arreglo de tamaño nxn lleno de ceros.

Al recorrer la matriz por cada fila f y columna c, si la posición matriz[f,c] es la primera columna a la izquierda (c==0) o la diagonal (f==c) se escribe 1.

Si la posición de la matriz[f,c] es debajo de la diagonal, se suman los valores de las casilla inmediata superior e izquierda superior.

pascal[f,c] = pascal[f-1,c] + pascal[f-1,c-1]

Al terminar el recorrido se tendrá la matriz con el triángulo de Pascal.

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

Tarea: Convertir el algoritmo a función.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2003_T2 Mostrar un triángulo de Pascal
# propuesta: edelros@espol.edu.ec

import numpy as np

# INGRESO
n = int(input('tamaño del triangulo: '))

# PROCEDIMIENTO
pascal = np.zeros(shape=(n,n),dtype=int)
f = 0
while (f<n):
    c = 0
    while (c<=f):
        if (c==0 or c==f):
            pascal[f,c] = 1
        else:
            pascal[f,c] = pascal[f-1,c] + pascal[f-1,c-1]
        c = c+1
    f = f+1

print(pascal)

resultado del algoritmo en una matriz

tamaño del triangulo: 10
[[  1   0   0   0   0   0   0   0   0   0]
 [  1   1   0   0   0   0   0   0   0   0]
 [  1   2   1   0   0   0   0   0   0   0]
 [  1   3   3   1   0   0   0   0   0   0]
 [  1   4   6   4   1   0   0   0   0   0]
 [  1   5  10  10   5   1   0   0   0   0]
 [  1   6  15  20  15   6   1   0   0   0]
 [  1   7  21  35  35  21   7   1   0   0]
 [  1   8  28  56  70  56  28   8   1   0]
 [  1   9  36  84 126 126  84  36   9   1]]
>>>

Ejercicio: 2Eva_IT2003_T1 Funciones promedio, mayor y menor

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

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IT2003_T1 Funciones promedio, mayor y menor
# Se EVALUA escribir un algoritmo
# Evite usar las funciones del lenguaje de programación
# Propuesta de Solución: edelros@espol.edu.ec

def promedio(vector):
    n = len(vector)
    suma = 0
    for i in range(0,n,1):
        suma = suma + vector[i]
    prm = suma/n
    return (prm)

def mayor(vector):
    n = len(vector)
    # Busca cual es el mayor
    max = 1
    for i in range(0,n,1):
        if (vector[i]>vector[max]):
            max = i
    # presenta el valor de mayor
    z = vector[max]
    return (z)

def menor(vector):
    n = len(vector)
    # Busca cual es el menor
    min = 1
    for i in range(0,n,1):
        if (vector[i]<vector[min]):
            min = i
    # presenta el valor de menor
    z = vector[min]
    return (z)


# PROGRAMA de prueba de funciones
import numpy as np

# INGRESO
meses = 12
temperatura = np.zeros(meses,dtype=int)
for mes in range(0,meses,1):
    temperatura[mes] = int(input("temperatura["+str(mes+1)+"]: "))

# PROCEDIMIENTO
tprom = promedio(temperatura)
tmax  = mayor(temperatura)
tmin  = menor(temperatura)
diferencia = tmax-tmin

# SALIDA
print("promedio: "+str(tprom))
print("Diferencia max-min: "+str(diferencia))

resultado del algoritmo

temperatura[1]: 30
temperatura[2]: 32
temperatura[3]: 30
temperatura[4]: 28
temperatura[5]: 29
temperatura[6]: 25
temperatura[7]: 25
temperatura[8]: 23
temperatura[9]: 25
temperatura[10]: 27
temperatura[11]: 29
temperatura[12]: 30
promedio: 27.75
Diferencia max-min: 9

Ejercicio: 2Eva_IIT2002_T3 Encriptar PIN(4 dígitos)

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

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2002_T3 Encriptar PIN(4 dígitos)
# Propuesta: edelros@espol.edu.ec

# literal a. funcion 
def encripta(n):
    a = (n%10)+7
    n = int(n/10)

    b = (n%10)+7
    n = int(n/10)

    c = (n%10)+7
    
    d = int(n/10)+7

    a = a%10
    b = b%10
    c = c%10
    d = d%10

    z = b*1000+a*100+d*10+c
    return (z)

# literal b. PROGRAMA
# INGRESO
clave = int(input('¿cuál es su clave?: '))
while (clave>9999):
    print(' la clave es de 4 digitos')
    clave = int(input('¿cuál es su clave?: '))

# PROCEDIMIENTO
r = encripta(clave)

# SALIDA
print('clave encriptada es: ', r)

resultado del algoritmo

¿cuál es su clave?: 1254
clave encriptada es:  2189
>>> 

Ejercicio: 2Eva_IIT2002_T1 Número perfecto

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

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2002_T1 Número perfecto
# Propuesta de solución: edelros@espol.edu.ec

import numpy as np

# literal a. funcion
def perfecto(n):
    suma = 0
    i = 1
    while (i<n):
        residuo = n%i
        # Acumula solo si i es divisor
        if residuo == 0:
            suma = suma + i
        i = i + 1
    if n == suma:
        esperfecto = 1
    else:
        esperfecto = 0
    return (esperfecto)


# literal b. PROGRAMA ----------
# Nota, busca numeros perfectos entre [1,m]

# INGRESO
m = int(input('¿rango m? : '))

# PROCEDIMIENTO
encontrado = np.zeros(m+1,dtype=int)
k = 0
i = 1
while (i<=m):
    encontrado[i] = perfecto(i)
    i = i+1

# SALIDA
i = 1
while (i<=m):
    if encontrado[i]==1:
        print(i)
    i=i+1

resultado del algoritmo
Nota: cambiando el enunciado, se busca números perfectos en el rango [1,m]

¿rango m? : 50
6
28
>>> 
¿rango m? : 1000
6
28
496
>>> 
¿rango m? : 10000
6
28
496
8128
>>> 

Ejercicio: 2Eva_IIT2001_T3 Flujo de ahorro para n años

Propuesta de solución en Python:

Se crea una funcion para evaluar el flujo de efectivo del periodo usando los valores anteriores. Con lo que se puede aplicar a cada valor de capital Ck de la tabla ingresada en el bloque de inicio.

Flujo de efectivo usando arreglos

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2001_T3 Flujo de ahorro para n años
# TAREA: continuar para otros valores k
import numpy as np

# literal a. función recursiva

def flujo(k,i1,i2,c):

    if (k>0):
        if (flujo(k-1,i1,i2,c)>=0):
            resultado = (1+i1)*flujo(k-1,i1,i2,c)+c[k]
        else:
            resultado = (1+i2)*flujo(k-1,i1,i2,c)+c[k]

    if (k==0):
        resultado = 0
    return(resultado)


# literal b. PROGRAMA

# INGRESO
k  = int(input('cual año: '))
i1 = float(input('tasa i1: '))
i2 = float(input('tasa i2: '))

c = np.array([-500, 300, 600, -200,
              300, -200, -300, 350])

# valores de c[k]
##n = int(input(' cuantos años: '))
##c = np.zeros(n,dtype=float)
##for anio in range(0,n,1):
##    c[anio] = float(input('c['+str(anio)+']: '))

# PROCEDIMIENTO
valor = flujo(k,i1,i2,c)
# TAREA: continuar para otros valores k

#SALIDA
print('valor: ', valor)

Resultado del algoritmo

Tomando como punto de partida los saldos «c» del enunciado

• en el año 1, como el saldo del año anterior fué negativo, no se pagan intereses, por lo que el saldo es el mismo del año, 300 dólares
• en el año 2, como el saldo del año anterior fué positivo, se reciben intereses del saldo, que corresponden a 18 dólares.

cual año: 0
tasa i1: 0.05
tasa i2: 0.10
valor:  0
>>> 
cual año: 1
tasa i1: 0.06
tasa i2: 0.10
valor:  300.0
>>> 
cual año: 2
tasa i1: 0.06
tasa i2: 0.10
valor:  918.0
>>> 
cual año: 3
tasa i1: 0.06
tasa i2: 0.10
valor:  773.08
>>> 

Ejercicio: 2Eva_IIT2001_T4 Control de habitaciones en una clínica

Propuesta de solución en Python:

Control de habitaciones en una clínica.

Se plantea usar una lista para los datos de paciente y un arreglo para la ocupación de las habitaciones.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2001_T4 Control de habitaciones en una clínica
# Tarea: abrir archivo de datos

import numpy as np

paciente=[]

# menu
opcion = '0'
while not(opcion=='6'):
    print(' 1. Ingresar habitaciones')
    print(' 2. Ingresar paciente y asignar habitación')
    print(' 3. Dar de alta a paciente, habitacion libre')
    print(' 4. Guardar datos de paciente')
    print(' 5. Abrir datos de pacientes')
    print(' 6. Salir')

    opcion = input('cual opcion: ')
    
    if (opcion=='1'):
        print(' **** 1. Ingresar habitaciones ****')
        n = int(input('cuantas:'))
        habitacion = np.zeros(n,dtype=int)
        print(habitacion)
        
    if (opcion=='2'):
        print(' **** 2. Ingresar paciente y asignar habitación ****')
        cedula = input('cedula: ')
        nombre = input('nombre: ')
        codigo = int(input('cual habitación: '))
        while (habitacion[codigo]==1):
            print(' la habitacion está ocupada,..')
            codigo = int(input('cual habitación: '))
            
        registro = [cedula,nombre,codigo]
        paciente.append(registro)

        habitacion[codigo] = 1

        print(paciente)
        
    if (opcion=='3'):
        print(' **** 3. Dar de alta a paciente, habitacion libre ****')
        print(paciente)
        cualpaciente=int(input(' numero paciente:'))
        donde=paciente[cualpaciente][2]
                
        if (habitacion[donde]==1):
            habitacion[donde] = 0
            paciente[cualpaciente][2] = 0
        else:
            print(' la habitacion no tiene paciente')
        print(habitacion)

    if (opcion=='4'):
        
        print(' **** 4. Guardar archivo ****')
        # trabajar con un archivo
        archivo = open('pacientes.txt','w')

        n = len(paciente)
        fila = 0
        while not(fila>=n):

            # Crea linea de texto con datos
            # para un registro, separada por comas
            registro = paciente[fila][0]+',' + paciente[fila][1] +',' +str(paciente[fila][2]) +'\n'

            # Escribe registro en una línea del archivo
            archivo.write(registro)
            fila = fila+1
            
        archivo.close()     # Cierra el archivo 

    if (opcion=='5'):
        print(' 5. **** Abrir archivo ****')
        print(' # TAREA, COMPLETAR EL PROCESO')
                
    if (opcion=='6'):
        print(' 6. **** Salir ****')

completar la tarea.

resultado del algoritmo

 1. Ingresar habitaciones
 2. Ingresar paciente y asignar habitación
 3. Dar de alta a paciente, habitacion libre
 4. Guardar datos de paciente
 5. Abrir datos de pacientes
 6. Salir
cual opcion: 1
 **** 1. Ingresar habitaciones ****
cuantas:10
[0 0 0 0 0 0 0 0 0 0]
 1. Ingresar habitaciones
 2. Ingresar paciente y asignar habitación
 3. Dar de alta a paciente, habitacion libre
 4. Guardar datos de paciente
 5. Abrir datos de pacientes
 6. Salir
cual opcion: 1
 **** 1. Ingresar habitaciones ****
cuantas:10
[0 0 0 0 0 0 0 0 0 0]
 1. Ingresar habitaciones
 2. Ingresar paciente y asignar habitación
 3. Dar de alta a paciente, habitacion libre
 4. Guardar datos de paciente
 5. Abrir datos de pacientes
 6. Salir
cual opcion: 2
 **** 2. Ingresar paciente y asignar habitación ****
cedula: 123
nombre: Juan
cual habitación: 8
[['123', 'Juan', 8]]
 1. Ingresar habitaciones
 2. Ingresar paciente y asignar habitación
 3. Dar de alta a paciente, habitacion libre
 4. Guardar datos de paciente
 5. Abrir datos de pacientes
 6. Salir
cual opcion: 2
 **** 2. Ingresar paciente y asignar habitación ****
cedula: 234
nombre: Maria
cual habitación: 8
 la habitacion está ocupada,..
cual habitación: 7
[['123', 'Juan', 8], ['234', 'Maria', 7]]
 1. Ingresar habitaciones
 2. Ingresar paciente y asignar habitación
 3. Dar de alta a paciente, habitacion libre
 4. Guardar datos de paciente
 5. Abrir datos de pacientes
 6. Salir
cual opcion: 3
 **** 3. Dar de alta a paciente, habitacion libre ****
[['123', 'Juan', 8], ['234', 'Maria', 7]]
 numero paciente:0
[0 0 0 0 0 0 0 1 0 0]
 1. Ingresar habitaciones
 2. Ingresar paciente y asignar habitación
 3. Dar de alta a paciente, habitacion libre
 4. Guardar datos de paciente
 5. Abrir datos de pacientes
 6. Salir
cual opcion: 4
 **** 4. Guardar archivo ****
 1. Ingresar habitaciones
 2. Ingresar paciente y asignar habitación
 3. Dar de alta a paciente, habitacion libre
 4. Guardar datos de paciente
 5. Abrir datos de pacientes
 6. Salir
cual opcion: 5
 5. **** Abrir archivo ****
 # TAREA, COMPLETAR EL PROCESO
 1. Ingresar habitaciones
 2. Ingresar paciente y asignar habitación
 3. Dar de alta a paciente, habitacion libre
 4. Guardar datos de paciente
 5. Abrir datos de pacientes
 6. Salir
cual opcion: 6
 6. **** Salir ****
>>> 

Ejercicio:  2Eva_IT2003_T4 Registro de carros en archivo

Propuesta de solución en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IT2003_T4 Registro de carros en archivo
# Tarea: validar datos de ingreso

# INGRESO
n = int(input('cuantos carros: '))
tabla = []
i = 0
while (i<n):
    print('Datos del carro: ... ',i)
    placa = input('Placa: ')
    anio  = input('año: ')
    tipo  = input('tipo A/auto C/camioneta: ')
    marca = input('marca: ')
    color = input('color: ')
    precio = input('precio: ' )

    registro = [placa,anio,tipo,marca,color,precio]
    tabla.append(registro)
    i = i+1

# PROCEDIMIENTO
# literal a)
nombre  = 'carros.dat'
archivo = open(nombre,'w')
i = 0
while (i<n):
    linea = ''
    j = 0
    while (j<6):
        linea = linea + tabla[i][j] + ','
        j = j + 1
    linea = linea.strip(',')+'\n'
    archivo.write(linea)
    i = i + 1
    
archivo.close()

# literal b
selecciona = []
i = 0
while (i<n):
    if (int(tabla[i][1])>1995 and tabla[i][4]=='rojo' and int(tabla[i][5])<6000):
        selecciona.append(tabla[i][0])
    i = i + 1

# SALIDA
print('archivo guardado')
print(' los autos que cumplen el pedido son:')
print(selecciona)