Consideremos una función que determine si una fecha dada (d, m, a) es valida:

Transcripción

1 CodeHood arreglo Establecimos anteriormente que una variable es un lugar en la memoria de la computadora donde podemos guardar un valor entre dos o más que puede haber en un conjunto, como un número entero, real, o un simple valor lógico, como 0 y 1. A una variable solemos asignarle un primer valor conveniente, como 0 para acumular una suma, 0 a un contador, 1 para una premisa sobre si un valor cumple con cierta condición. Pero afirmamos que al asignarle un nuevo valor a la misma variable, el valor anterior se pierde o destruye. En lo adelante diremos que tales variables son escalares, similares a las magnitudes escalares en física, como la masa y el tiempo, que basta la magnitud para definirlas. Podemos también definir variables vectoriales, similares a las magnitudes vectoriales en física, que requieren varios atributos para definirlas, como la velocidad y el peso. Una variable vectorial, que aquí llamaremos arreglo, permite alojar múltiples valores bajo un mismo nombre, que se pueden acceder individualmente mediante el nombre del arreglo y un subíndice. El uso de arreglos nos permite dar un paso adicional en la generalización de nuestro código, como hicimos con el concepto de variable, ciclo y función. De hecho, las sentencias secuenciales (asignar, escribir, leer, invocar, retornar), las selectivas (si), la repetitivas (mientras), las funciones y los arreglos, en teoría, son todo lo necesario para abordar cualquier problema computacional que admita solución. Consideremos una función que determine si una fecha dada (d, m, a) es valida: fechvali(d, m, a): # si fecha es valida si mesvali(m) = 0: sino: si diavali(d, m, a) = 0: Asumimos que el año, s, es siempre válido, y también que la fecha es valida a menos que encontremos evidencia en contra. Entonces verificamos si el mes es valido, invocando la función mesvali, pasándole a m, el numero del mes, y si nos retorna 0 ( falso) concluimos que la fecha no es válida asignando 0 a v y saltando a la sentencia retorna. Pero si el mes es válido, entonces invocamos a la función mesvali (después del sino) pasándole los valores de d, m, a, para verificar si el día es valido, bajo la premisa de que tanto el ano como el mes son válidos., y si nos retorna un 0, concluimos que la fecha no es valida, asignando 0 a v. El código de la función mesvali podría ser, pues basta verificar si m esta en el intervalo [1, 12], como entero, claro: mesvali(m): # si m es un numero valido de mes si m < 1 o m > 12: Pero verificar si el día es valido es un poco mas complicado porque hay que tomar en cuenta que hay meses de 28, 30 y 31 días,

2 y que si el año es bisiesto febrero tiene 29 días. Podemos imaginar la cantidad y complejidad de verificaciones para determinar si el día de una fecha es valido bajo estas condiciones. Pero usando un arreglo se simplifica sustancialmente: diavali(d, m, a): # si fecha (d, m, a) es válida dm = [31,28,31,30,31,30,31,31,30,31,30,31] si bisiesto(a): dm[1] = 29 si d < 1 o d > dm[m-1]: Definimos a dm como un arreglo y colocamos en él, en orden el número de los días que tiene cada mes. Hay que tomar en cuenta que el primer valor, 31, es colocado en memoria en la posición 0 del arreglo dm esto es, en dm[0]. Por eso si el año es bisiesto se asigna 29 a dm[1], que corresponde al numero de días del mes 2, febrero, y por lo mismo, el numero de días del mes m esta en la posición dm[m- 1], como se verifica en el segundo si, de manera que el día no es valido si es menor que 1 o mayor que el numero de días del mes m- 1, dm[m- 1]. El uso del arreglo dm evita tener que verificar si el mes es de 30 o 31 días. Un código corto, limpio y elegante. Solo nos falta ver la función bisiesto. Para ello tomaremos la definición de que un año es bisiesto si es múltiplo de 4, pero no múltiplo de 100, excepto si es múltiplo de 400, en cuyo caso sí es bisiesto: bisiesto(a): # si a corresponde a un año bisiesto b = 0 si (a%4 = 0 y a%100 <> 0) o (a%400 = 400): b = 1 retorna b Ya que estamos tratando de fechas, consideremos una función que dada una fecha (d, m, a) válida, obtenga la fecha del día siguiente, esto es, para (27,2,2015) debe darnos (28,2,2015), esto es, solo se le suma 1 a d, y esto será así para todos los días del año, excepto los de fin de mes, pues para (28,2,2015) el día siguiente es (1,3,2015), cambia el día y el mes, y para (31,12,2015) el día siguiente es (1,1,2016), cambia el día, el mes, y el año. Nuevamente, para lograr una solución elegante acudimos a un arreglo: diasigui(d, m, a): # fecha del día siguiente a fecha (d,m,a) dm = [31,28,31,30,31,30,31,31,30,31,30,31] dm[1] += bisiesto(a) d = d + 1 si d > dm[m-1]: d = 1 m = m + 1 si m > 12: m = 1 a = a + 1 retorna d, m, a Notemos que la función diasigui retorna tres valores, d, m, a, que es la fecha del siguiente a la fecha recibida. Vemos que ahora sumamos a dm[1], el número de días de febrero, el valor retorne la función bisiesto al pasarle a, el año. Esto funciona porque si el año es bisiesto, bisiesto 1 y 0 si no lo es. Luego se le suma 1 a d, que casi siempre es todo lo que hay que hacer; pero si luego de este incremento el valor de d supera al numero de días de ese mes, dm[m- 1], entonces se asigna 1 a d y se suma 1 a m,

3 para pasar al primero del mes siguiente, como debe ser. Y si por si no solo era fin de mes, sino de año, en cuyo caso el mes el mes paso a ser 13, entonces se asigna 1 al mes, para pasar a enero y se suma 1 a la variable a porque hay un cambio de año. No hace falta hacer 1 a d, pues acaba de hacerse por ser fin de mes, de diciembre. Una función que obtenga la fecha que sigue t días a otra podría ser: fechprox(d, m, a, t): # fecha (d, m, a) t días posterior a otra dada mientras t > 0: d, m, a = diasigui(d, m, a) t = t 1 retorna d, m, a Como el ciclo se ejecuta exactamente t veces y cada vez que se invoca a la función diasigui retorna la fecha del día siguiente tomando en cuenta los números variables de días de los meses y si el año es bisiesto, la fecha final retornada es la que corresponde a t días después de la recibida. De hecho, cuando t es 7, tenemos la fecha de una semana después, por ejemplo. Consideremos una función para promediar t números reales, que son leídos desde dentro de la misma función: promedio(t): # promedia t números reales, leídos localmente.0 mientras t > 0: lee v p = p + v t = t - 1 retorna p/t Separemos los momentos de lectura de los t números y de promediarlos, porque bien pusiera ser que hay que leerlos una sola vez y luego realizar distintas acciones sobre ellos, como promediarlos, obtener el mayor, o el menor. La función promedio recién presentada una variable escalar para leer los t números reales sin que haya efecto colateral si sólo interesa el promedio, porque los valores leídos se van sumando según se leen. Pero si una función va solo a leer los t valores, debe guardarlos en un arreglo porque no se sabe de antemano el valor de t: leenum(v, t): # lee t números reales mientras i < t: lee v[i] i = i + 1 Esta función retorna el arreglo v con las primeras t posiciones pobladas con los valores leídos. Una función que obtenga el promedio de estos t valores, asumiendo que el arreglo esta poblado, podría ser: promedia(v, t): # promedia t números reales mientras i < t: p = p + lee v[i] i = i + 1 retorna p/t Un algoritmo que promedia t números reales, usando primero una función para poblar un arreglo y luego otra para

4 promediarlos, podría ser: algoritmo: # promedia t números reales t = 17 v = [t] v = leenum(v, t) p = promedia(v, t) escribe p Ahora los detalles de leer los t reales y promediarlos están separados, por lo que podríamos realizar otras operaciones sobre los valores en el arreglo, como ordenarlos, u obtener el máximo. Una versión en lenguaje C de este algoritmo completo podría ser: #include <stdio.h> void leenum(double [], long); double promedio(double [], long); int main() // promedio de t reales long t = 5; double p = 0, v[t]; // promedio, valores leenum(v, t); p = promedio(v, t); printf("%lf", p); return 0; void leenum(double v[], long t) // lee t reales en v long ; while (i < t) scanf("%lf", &v[i++]); double promedio(double v[], long t) // promedia t valores en v double ; long ; while (i < t) p += v[i++]; return p/t; Una versión en Python podría ser: # promedia t reales def leenum(v, t): # lee t reales en v while i < t: e = raw_input() v[i] = float(e) i += 1

5 def promedio(v, t): # promedia t valores en v ; while (i < t): p += v[i] i += 1 return p/t t = 5 p = 0 # crea/inicia v mediante una comprehension: v = [0.0 for i in range(t)] leenum(v, t) p = promedio(v, t) print p Ahora estamos listos para afrontar, a fuerza bruta, una amplia variedad de enunciados computacionales de complejidad inicial a media. Usaremos prosa para el análisis y estrategia, y phyton para implementar propuestas de soluciones. ecabrera, sdqdr, febrero 2015