Ejemplos de conversión de reales a enteros

Transcripción

1 Ejemplos de conversión de reales a enteros Con el siguiente programa se pueden apreciar las diferencias entre las cuatro funciones para convertir de reales a enteros: program convertir_real_a_entero print *, 'Truncamiento:' print *, 10.3, '->', int( 10.3) print *, 10.5, '->', int( 10.5) print *, 10.7, '->', int( 10.7) print *, -10.3, '->', int(-10.3) print *, -10.5, '->', int(-10.5) print *, -10.7, '->', int(-10.7) print *, 'Hacia abajo:' print *, 10.3, '->', floor( 10.3) print *, 10.5, '->', floor( 10.5) print *, 10.7, '->', floor( 10.7) print *, -10.3, '->', floor(-10.3) print *, -10.5, '->', floor(-10.5) print *, -10.7, '->', floor(-10.7) print *, 'Hacia arriba:' print *, 10.3, '->', ceiling( 10.3) print *, 10.5, '->', ceiling( 10.5) print *, 10.7, '->', ceiling( 10.7) print *, -10.3, '->', ceiling(-10.3) print *, -10.5, '->', ceiling(-10.5) print *, -10.7, '->', ceiling(-10.7) print *, 'Mas cercano:' print *, 10.3, '->', nint( 10.3) print *, 10.5, '->', nint( 10.5) print *, 10.7, '->', nint( 10.7) print *, -10.3, '->', nint(-10.3) print *, -10.5, '->', nint(-10.5) print *, -10.7, '->', nint(-10.7) end program convertir_real_a_entero Comportamiento de la función mod El siguiente programa ilustra el comportamiento de la función mod cuando el segundo argumento es 3: program modulo integer :: i do i = -10, 10 print *, i, 'mod', 3, '==', mod(i, 3) end program modulo

2 Comentador de notas Problema: escribir un programa que le pregunta la nota al usuario, y la clasifica como pésima, mala, buena o excelente. El código es el siguiente: program comenta_nota integer :: nota print *, 'Ingrese su nota:' read *, nota if (nota < 40) then print *, 'Pesimo' else if (nota < 55) then print *, 'Mal' else if (nota < 70) then print *, 'Bien' else if (nota <= 100) then print *, 'Excelente' else print *, ' Mentira!' end program Un par de cosas importantes de notar: Cada vez que una condición de un if es falsa, el flujo del programa pasa a su sección else, donde se puede dar por hecho que la condición ya no se cumple. Por eso no es necesario volver a comprobar que la nota es mayor a 40, pues si así fuera, el programa jamás habría llegado a las siguientes condiciones. Cuando se usan varios if encadenados (cada uno en la sección else del anterior) sólo es necesario poner un al final (a diferencia de como lo hice yo en clases). Cada elseif puede ser considerado una extensión del primer if. Secuencia de Collatz Problema: escribir un programa que muestre por pantalla la secuencia de Collatz de un número entero ingresado por el usuario. El algoritmo consiste simplemente en aplicar la regla para generar la secuencia, y terminar cuando se haya llegado al valor 1. El código es el siguiente: program collatz

3 integer :: n print *, 'Ingrese n' read *, n do while (n > 1) if (mod(n, 2) == 0) then n = n / 2 else n = 3 * n + 1 print *, n end program collatz Números primos Problema: escribir un programa que indique si el número entero ingresado por el usuario es primo o no. El algoritmo consiste en partir suponiendo que el número es primo, e intentar encontrar un divisor entre 2 y n 1. Si se encuentra alguno, entonces el número no es primo. Si no se encuentra ninguno, entonces el supuesto sigue siendo cierto. El código es el siguiente: program primo integer :: n, d logical :: es_primo print *, 'Ingrese un numero entero:' read *, n es_primo =.true. do d = 2, n - 1 if (mod(n, d) == 0) then es_primo =.false. exit if (es_primo) then print *, n, 'es primo' else print *, n, 'es compuesto' end program primo

4 Ejercicio 1: promedio de tres números Escriba un programa que muestre el promedio de tres números reales ingresados por el usuario. Ingrese tres numeros: El problema es bastante sencillo: basta con leer los tres números, guardarlos en tres variables, y luego promediarlos: program promedio_3 real :: x, y, z real :: promedio print *, 'Ingrese tres numeros:' read *, x read *, y read *, z promedio = (x + y + z) / 3 print *, promedio end program promedio_3 Algunas variaciones son posibles. Por ejemplo, la variable promedio puede ser omitida si la expresión es puesta directamente en la sentencia print: print *, (x + y + z) / 3 La lectura de las tres variables puede hacerse en la misma línea: read *, x, y, z Las cuatro variables pueden ser declaradas en la misma línea, o en cuatro líneas separadas. En general, siempre debe elegirse la manera que hace que el código sea más claro y fácil de entender. En este caso, el programa es tan simple que no hay mucha diferencia entre una manera u otra. Ejercicio 2: promedio de n números Escriba un programa que:

5 pregunte al usuario cuántos números ingresará, pida al usuario que ingrese los números, y muestre el promedio de los números. Cuantos numeros ingresara? 5 Ingrese los numeros El promedio es A diferencia con el problema anterior, ahora no es posible guardar cada valor en una variable, ya que la cantidad de variables es fija para cada programa, y la cantidad de números ingresados es arbitraria. Antes de escribir cualquier línea de código, hay que pensar en la estrategia a seguir. Para este problema, la mejor estrategia es ir sumando los números a medida que van siendo ingresados, y al final dividirlos por la cantidad. La manera típica de sumar cosas en un programa es usar una variable para ir acumulando el resultado. Es importante que esta variable sea inicializada con el valor cero antes de comenzar a sumar: suma = 0.0 do... suma = suma + x Como el número de iteraciones del ciclo es conocido de antemano (ya que el usuario lo ingresó), conviene usar el ciclo do con contador. También se puede hacer con do while, pero es un poco más complicado. La solución es la siguiente: program promedio_n integer :: i, n real :: x, suma, promedio print *, 'Cuantos numeros ingresara?' read *, n print *, 'Ingrese los numeros' suma = 0.0 do i = 1, n read *, x suma = suma + x

6 promedio = suma / real(n) print *, 'El promedio es', promedio end program promedio_n Aquí he ocupado la función real en el cálculo del promedio para enfatizar que la división es una operación de números reales. En la práctica no es necesario, ya que si un operando es real, el otro es convertido automáticamente a real. Problema 3: promedio de números hasta marcar el final Escriba un programa que: pida al usuario que ingrese varios números, se detenga cuando encuentre un número negativo, y muestre el promedio de todos los números positivos ingresados. Ingrese los numeros El promedio es Este problema tiene una dificultad adicional en relación al anterior: ahora la cantidad de valores no es conocida en ningún momento. Esto conlleva a dos cambios importantes en el programa: ya no se puede usar el ciclo do con contador, sino que hay que usar do while, ya que el ciclo termina cuando una condición deja de cumplirse; hay que llevar la cuenta de los números ingresados, para saber por cuánto hay que dividir al final. La manera típica de contar cosas es similar a cómo se suman cosas, salvo que la variable acumuladora debe ser entera e ir siendo incrementada de uno en uno: cuenta = 0 do... cuenta = cuenta + 1 Una precaución importante es asegurarse que el programa hace por lo menos un read. Por ejemplo, en el siguiente código, el programa nunca entrará al ciclo si el valor inicial de x es negativo: do while (x >= 0)

7 read *, x cuenta = cuenta + 1 suma = suma + x Una manera de asegurarse que entre al ciclo es asignando un valor positivo cualquiera a x, que de todos modos será borrado al hacer el read. Otra opción es hacer el primer read afuera del ciclo, y luego hacer uno al final de él, que es lo que hice yo: program promedio_hasta_negativo integer :: cuenta real :: x, suma, promedio print *, 'Ingrese los numeros' suma = 0.0 cuenta = 0 read *, x do while (x >= 0) cuenta = cuenta + 1 suma = suma + x read *, x promedio = suma / cuenta print *, 'El promedio es', promedio end program promedio_hasta_negativo Otra opción es usar un ciclo infinito, y salir de él inmediatamente después de leer un valor si es que éste es negativo: do read *, x if (x < 0) then exit cuenta = cuenta + 1 suma = suma + x Lecciones importantes Si algo debe hacerse varias veces, debe ir dentro de un ciclo. Todas las variables usadas en un programa deben ser declaradas.

8 Antes de escribir código, hay que pensar en el algoritmo. La mejor manera es pensar «cómo lo haría yo a mano?». Hay que usar notación de programación, no de matemáticas: ab2 está mal; a / (b ** 2) está bien. Ejercicio 1: ruteo Rutee el siguiente programa (del certamen 1 del semestre pasado): program ruteo logical :: t integer :: i, j j = 5 do i = 4, 2, -1 j = 6 - mod(i, 2) t = j > mod(j, 5) if (t) then print *, 'j =', j t =.FALSE. else print *, 'j =', j t =.TRUE. end program ruteo Las reglas para el ruteo son: una columna para cada variable; se cambia el valor de una variable en la tabla sólo cuando: o hay una asignación, o o hay una lectura de datos (read); cuando el programa hace salida (print), se escribe en la columna «salida estándar» lo que el programa imprime por pantalla; cada fila de la tabla corresponde a una única sentencia del programa, por lo que no se ponen varios valores en una fila. El ruteo es el siguiente: t i j Salida estándar 5 4

9 t i j Salida estándar TRUE. j = 6.FALSE. Ejercicio 2: menor y mayor Escriba un programa que pida al usuario que ingrese diez valores, y muestre el menor y el mayor de los números ingresados. ingresados por el usuario. Ingrese 10 valores El menor es El mayor es Como siempre, hay que pensar bien el algoritmo antes de escribir cualquier línea de código. Una opción puede ser guardar los valores en diez variables, y luego comenzar a comparar de a pares para encontrar el menor y el mayor. Ésta no es la manera más simple ni la más elegante, e impide aplicar el mismo programa cuando el número de valores es distinto de 10.

10 La alternativa elegante es la siguiente. Desde el principio, recordar siempre cuáles son el menor y el mayor valor visto hasta el momento. Cada vez que se lee un nuevo dato, se actualizan ambos valores en caso que sea el nuevo mayor o el nuevo menor. El ciclo principal queda así: do i = 1, 10 read *, x if (x < menor) then menor = x if (x > mayor) then mayor = x El problema que queda por resolver es cómo inicializar mayor y menor, pues ambos ya deben tener un valor para poder ser usados al entrar al ciclo por primera vez. Una solución simple es inicializar menor con un valor positivo muy grande, y mayor con un valor negativo muy grande. Así el primer valor de x leído será automáticamente el menor y el mayor. En clases yo ocupé los valor 1e300 y -1e300, pero estos valores no son válidos!, ya que el rango de las variables de tipo real llega aproximadamente hasta 3.4e38 (esto es 3,4 1038). Afortunadamente existe una función llamada huge que entrega el mayor valor posible que puede tomar una variable. La inicialización puede hacerse así: menor = huge(x) mayor = -huge(x) Otra alternativa es leer el primer valor de x fuera del ciclo, inicializar mayor y menor con el valor de x y luego hacer el ciclo desde 2 hasta 10. El programa completo usando esta estrategia es el siguiente: program mayor_y_menor real :: x, mayor, menor integer :: i integer, parameter :: N = 10 print *, 'Ingrese', N, 'valores' read *, x menor = x mayor = x do i = 2, N read *, x

11 if (x < menor) then menor = x if (x > mayor) then mayor = x print *, 'El menor es', menor print *, 'El mayor es', mayor end program mayor_y_menor En este programa definimos una constante N para referirnos siempre a la cantidad de elementos. Esto permite adecuar el mismo programa para cualquier cantidad de datos tan sólo con modificar el valor de N en la declaración. En clases ruteamos el programa usando N = 4 y usando como entrada los valores 2, 1, 4 y 3: x menor mayor i Salida estándar El menor es 1.0

12 x menor mayor i Salida estándar El mayor es 4.0 Control 2: ruteo Rutee el siguiente programa: program control2 integer :: p, i, a logical :: s a = 4 p = 0 s =.TRUE. do i = 1, 2 * a - 1 if (s) then p = p + 1 s =.not. s print *, p end program control2 He aquí el ruteo: p i a s Salida estándar 0 4.TRUE. 1 1.FALSE. 2.TRUE.

13 p i a s Salida estándar 2 3.FALSE. 4.TRUE. 3 5.FALSE. 6.TRUE. 4 7.FALSE. 4 Ejercicio 1: invertir dígitos Escriba un programa que invierta los dígitos de un número entero ingresado por el usuario. Ingrese un numero entero El numero invertido es Ingrese un numero entero 2010 El numero invertido es 102

14 Para resolver este problema, lo que hay que lograr hacer es extraer los dígitos del número uno por uno para poder ir construyendo el número invertido: El último dígito de un número entero puede ser obtenido calculando el resto de su división por 10; los dígitos faltantes pueden ser obtenidos dividiendo el número por 10: n = print *, n / 10! print *, mod(n, 10)! 7 Cuántas veces debe hacerse este paso? El computador no sabe cuántos dígitos tiene el número. Lo más simple es ir dividiendo n hasta llegar a 0. Por lo tanto, hay que usar un ciclo do while y no un ciclo do con contador. Cada vez que el último dígito de n es calculado, hay que ponerlo al final del número invertido. La manera de hacerlo es la siguiente: invertido = invertido * 10 + ultimo_digito El programa queda así: program invertir integer :: n, invertido, ultimo_digito print *, 'Ingrese un numero entero' read *, n invertido = 0 do while (n /= 0) ultimo_digito = mod(n, 10) invertido = invertido * 10 + ultimo_digito n = n / 10 print *, 'El numero invertido es', invertido end program invertir Si ruteamos el programa con la entrada , el resultado es éste: n u_d inv Salida estándar

15 n u_d inv Salida estándar El número invertido es Ejercicio 2: palíndromos Escriba un programa que reciba un número entero e indique si es palíndromo o no. Ingrese un numero entero si es palindromo Ingrese un numero entero no es palindromo Un palíndromo es un número que se lee igual de izquierda a derecha y de derecha a izquierda. Habiendo hecho el ejercicio anterior, este problema es trivial: basta con comparar el número original con su versión invertida. Si (y sólo si) son iguales, entonces el número es un palíndromo.

16 La única precaución que hay que tener es la de guardar una copia del número ingresado para poder compararla al final, pues el proceso de invertir n hace que el valor se pierda. El programa es el siguiente: program palindromo integer :: n, original, invertido print *, 'Ingrese un numero entero' read *, n original = n invertido = 0 do while (n /= 0) invertido = invertido * 10 + mod(n, 10) n = n / 10 if (original == invertido) then print *, original, 'si es palindromo' else print *, original, 'no es palindromo' end program palindromo Ejercicio 3: números de Fibonacci Los números de Fibonacci son una secuencia que comienza con los valores 0 y 1, y a continuación todos los valores son la suma de los dos anteriores: F0 F1 Fk =0 =1 =Fk 2+Fk 1,k 2 Escriba un programa que pregunte al usuario cuántos números de Fibonacci desea, y los muestre por pantalla: Cuantos numeros de Fibonacci desea? La regla para generar los números de Fibonacci requiere siempre sumar los dos últimos valores. Por lo tanto, en cada etapa del procedimiento es necesario recordar los dos últimos números. Nos referiremos a ellos como el número actual y el número anterior.

17 Los dos primeros valores son siempre 0 y 1. Por lo tanto, podemos comenzar directamente imprimiéndolos: print *, 0 print *, 1 Por simplicidad, supondremos que el usuario siempre ingresa una cantidad n mayor que dos. Si queremos que el programa esté correcto en todos los casos, deberíamos hacer lo siguiente: if (n > 0) then print *, 0 if (n > 1) then print *, 1 Para generar el resto de los números, debemos describir el proceso en que anterior pasa a tomar el valor que tenía actual, y actual pasa a tener la suma de ambos. Una aproximación ingenua sería la siguiente: anterior = actual actual = anterior + actual Este cambio es incorrecto, ya que después de la primera asignación anterior pierde el valor que tenía previamente, por lo que la segunda asignación ya no hace lo que esperamos. Si cambiamos el orden de las asignaciones, ocurre lo mismo: actual = anterior + actual anterior = actual Ahora es el valor de actual el que se pierde antes de usarlo. Esta confusa situación ocurre siempre que se desea intercambiar el valor de dos variables. La manera de solucionarlo es introduciendo una variable adicional para guardar el resultado intermedio. A esta variable la denominaremos suma: suma = anterior + actual anterior = actual actual = suma El programa completo es el siguiente: program fibonacci integer :: anterior, actual, suma, k, n print *, 'Cuantos numeros de Fibonacci desea?' read *, n

18 print *, 0 print *, 1 anterior = 0 actual = 1 do k = 3, n suma = anterior + actual anterior = actual actual = suma print *, actual end program fibonacci El ciclo do parte desde 3 porque los primeros dos valores ya fueron mostrados antes. Tarea para la casa: escriba un programa que reciba como entrada un número entero e indique si es o no un número de Fibonacci. Ingrese un numero entero 17 no Ingrese un numero entero 21 si