Ejercicio: 2Eva_IIT2004_T1 Calcular raíz cúbica recursiva

Usar la fórmula recursiva:

considere controlar el número de iteraciones como máximo 100 veces (tarea). Para evitar un bucle infinito si la diferencia no disminuye (convergente).

Algoritmo en Python

# 2Eva_IIT2004_T1 Calcular raíz cúbica recursiva

def cubic(n, tolera = 0.0001):
    xi = 1
    diferencia = 1
    while (diferencia>tolera):
        xn = (2*(xi**3)+n)/(3*(xi**2))
        diferencia = abs(xn-xi)
        xi = xn
    return(xi)

resultado del algoritmo

>>> cubic(8)
2.0000000000120624
>>> cubic(27)
3.0000000000000973
>>> 

Ejercicio: 2Eva_IIIT2003_T3 función distancia de Hamming

Se deben comparar las cadenas U y V en los elementos de las mismas posiciones.
Primero se plantea un algoritmo para determinar el número de parejas diferentes que existen dentro de cada cadena.

Si las cadenas difieren en el tamaño, la respuesta será '-1'.

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

diferente= -1  # tamaño diferente U,V
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

Instrucciones en Python usando una función

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

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

Recuerde que toda función recursiva requiere un valor inicial para la primera iteración. Empezando para n=0 con el valor de x:

En el caso que n>1, se usa la expresión recursiva:

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

Observe que a partir de la iteración 6, ya no muestra diferencia entre resultados consecutivos.

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

Algoritmo en Python

La función no debe admitir valores de x negativos o cero, de darse el caso se responde np.NaN que corresponde a no es un número o 'Not a Number'.

# 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:
        # no se admiten negativos o cero
        f = np.NaN
    else:
        if n == 1:
            f = x/2  # valor inicial
        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_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.

Algoritmo en Python

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

ejercicios resueltos Python final_iit2003_t2 pdf

ejercicios resueltos Matlab final_iit2003_t2 pdf

Ejercicio:  2Eva_IT2003_T4 Registro de carros en archivo

Propuesta de solución en Python:

Se ingresan los datos de los carros en una lista, añadiendo los datos con la instrucción append().

Para el literal a, se concatenan los datos de una fila añadiendo una coma ',' como separador. se escribe cada línea en el archivo.

En el literal b, se recorre la lista analizando los datos de los carros para añadirlos en una lista aparte que contiene los datos de los seleccionados.

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

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

Se requiere desarrollar las funciones usando las operaciones para mostrar el conocimiento de los conceptos.

Como los datos se envían en un vector, se debe recorrer cada elemento del vector para obtener los resultados. Esta parte muestra su dominio del manejo de lazos/bucles con los índices de un arreglo.

Algoritmo en Python

# 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

ejercicios resueltos Python final_it2003_t1 pdf

ejercicios resueltos Matlab final_it2003_t1 pdf

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

Es necesario implementar las instrucciones dadas para armar el número

• A cada dígito súmele siete.
• Al resultado de esta suma, divídelo para 10 y extraiga el residuo.
• El valor resultante reemplaza al dígito original
• Intercambie el primer dígito con el tercero y el segundo con el cuarto.

Manteniendo el algoritmo simple, con el supuesto que siempre son cuatro dígitos, se extrae cada dígito en las variables a,b,c,d para aplicar las operaciones indicadas.

Algoritmo en Python

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

ejercicios resueltos Python final_iit2002_t3 pdf

ejercicios resueltos Matlab final_iit2002_t3 pdf

Ejercicio: 2Eva_IIT2002_T1 Número perfecto

Un número perfecto es aquel que es igual a la suma de todos sus divisores, con excepción del mismo.

Ejemplo:
 6 es perfecto porque, 
   sus divisores son: 1, 2, 3 (6 no se considera).
   1+2+3=6

literal a. verificar mediante una función perfecto(n)

Se busca entre todos los números enteros i entre 1 y n, revisando el residuo entre n%i. Si el residuo es cero, es divisible y se acumula en suma para verificar el número perfecto. Al final de la búsqueda si n==suma se considera el número como perfecto.

Algoritmo en Python

# 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

literal b. Listar números perfectos entre [1,m], consiste en crear una lista con todos los números que se verifican con la función creada en el literal a.

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

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

ejercicios resueltos Python final_iit2002_t1 pdf

ejercicios resueltos Matlab final_iit2002_t1 pdf

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

Propuesta de solución en Python:

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

La lista de pacientes empieza vacia paciente=[] y se añaden datos con cada ingreso de paciente a la clínica. paciente.append()

El arreglo de habitaciones se inicializa en la opción=1 con el número de habitaciones disponibles en el edificio. Como el edificio tiene un número de habitaciones fija, se inicializa como un arreglo de tamaño n, con valores ceros al iniciar con todas las habitaciones vacias.

Algoritmo en Python

# 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] +','
            registro = registro +',' +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_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

Algoritmo en Python

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