¿Qué tal, Perl en español? Acudo a Uds. con una duda de optimización de un proceso.

Creé una aplicación usando el módulo SpreadSheet::ParseExcel que me permite guardar en .txt los datos desde una hoja de Excel y también guardar en variables los parámetros que me servirán para realizar cálculos y finalmente generar un reporte.

A continuación les pongo una muestra de los datos, solo son cuatro columnas: la 0, 1, 2 y 3; aunque en la aplicación real son once columnas con las que trabajo.

Las columnas importantes son la 1 y la 2, o sea, la de la letra i y la de las fechas con horas.



Este archivo lo transformé de .xls a .txt y luego lo moví a un arreglo llamado @vector.

Bueno, la primera cuestión que quiero comentarles es que necesito buscar en el archivo completo si las fechas están en intervalos de 15 minutos. Si es así, dejar la columna 1 con la letra i y si no cambiar la i por una n.

Yo solucioné lo anterior con un ciclo for() que recorre el arreglo completo haciendo que la línea "actual" compare su fecha y hora con la fecha y hora de la línea "siguiente" y si es mayor de 15 minutos el intervalo pues que coloque una n en vez de la i en la línea "siguiente".

Además ingresará al vector @rango el número de linea que está fuera de rango y aumentará un contador de datos de fuera de rango "$contrango" en +1.

Aquí muestro mi código.



La segunda parte de la validación se compone de un proceso que se encarga de comprobar si hay fechas idénticas.

Esto lo solucioné con la ayuda de un for() "anidado" que se encarga de comparar la fecha-hora de la línea "actual" con TODAS las fechas-horas de las líneas que le siguen y si encuentra alguna igual pues que le colocará * en vez de la i a la línea actual y a la línea que está igual y también colocará una n de falla de rango a la línea que está después de la línea que es copia de la "actual".

También aumentará los contadores de repetidos "$contbis" y de rango "$contrango" e ingresará el número de registro de los datos repetidos al vector @repetidos y el número de registro del dato fuera de rango a @rango.

A continuación mi código.


Realizado lo anterior ya estamos listos para analizar los datos para crear el reporte

Quiero comentarles que mi programa funciona perfectamente pero los archivos que debo analizar se componen de un mínimo de 2400 registros.

Al realizar el análisis completo de los archivos por completo pero en "partes" (primero transformación xls, luego chequeo de rangos, luego chequeo de repetidos, luego análisis de datos, luego reporte) me di cuenta que la rutina que más tiempo lleva es la rutina de chequeo de repetidos(): casi 12 minutos para un archivo de 2880 registros lo cual es demasiado para un registro tan "pequeño" si lo comparamos con los registros que se acostumbran analizar en el lugar en el que estoy desarrollando la aplicación (800000 en un mal día).

Mi pregunta es si alguien me puede orientar hacia la forma de optimizar la rutina de chequeo de repetidos.

Gracias por adelantado

Si te das cuenta, en el primer código, puedes meter las líneas 20 a 31 detrás del if() de la 33...

Se ahorraría mucho tiempo si eliminaras todas las operaciones split() y join(). Para ello, solo tienes que transformar la estructura de líneas a una estructura bidimensional.

Por ejemplo:

A partir de esa línea, @vector ya es una estructura bidimensional. Cada elemento es una referencia a otro arreglo, que contiene todas las columnas ya separadas. Para acceder a la columna 2 de la línea $i, por ejemplo, sería así:
o, de forma abreviada:

Al final del proceso, tienes que hacer el proceso inverso:


Aún más... podríamos crear una estructura bidimensional con solo la información que nos interesa:
Estas líneas sacan una estructura como esta:
Como ves, ya tienes todos los elementos que necesitas para hacer las búsquedas y comparaciones. Los primeros seis campos tienen los componentes de la fecha. El octavo es la letra, que cambiaremos o no. Y para rehacer la línea original, solo tenemos que unir los campos siete a diez.

Esto te servirá para el primer caso, el de detectar que los tiempos están cada cuarto de hora. Para el segundo caso, puedes aprovechar la estructura ya creada, porque la fecha está en el campo nueve. Y para evitar el doble bucle, puedes usar la técnica de los hash: metes las fechas en un hash, como clave, a medida de que las vas leyendo, y como valor, guardas el número de línea en donde está, en forma de arreglo (push()). Así, por cada fecha, guardas todas las líneas en las que aparece esa fecha.

Solo un bucle más, donde recorremos el hash. Si, para una fecha, se repite más de una vez (su arreglo tiene más de un valor), actualizamos el valor de las letras y asteriscos de esos números de línea (ponemos asterisco en todos los valores, y 'n' en la línea siguiente, salvo que ya sea un asterisco).

Ya solo queda rehacer las líneas originales, sacándolas de la estructura bidimensional.

Realicé las operaciones y todo va muy bien, solo tengo duda con la utilización de



¿Cuál es el objeto de usar este par de líneas?




Me perdí en lo del push(), no sé si estoy en lo correcto pero ¿¿lo que me sugieres es que haga un Hash de Arrays?? Donde cada fecha sea una llave y cada "llave/fecha" se relacione con un arreglo al cual le "pusheare" los números de línea en que aparece dicha "fecha/llave".

¿Si son 2880 registros sería un hash de 2880 llaves hacia 2880 arreglos?

Si estoy en lo correcto... ¿una ayuda con la sintaxis del push() para el hash de arrays y para contar los elementos en cada array del hash?

Y si no te entendí bien, por favor ¿una ayuda con la sintaxis correcta?

Gracias por adelantado.

La de sacar en pantalla (más bien, en la salida de error estándar) la estructura del array @vector.

Eso es. Guardar, para cada fecha, en qué líneas aparece esa fecha.

2880, o menos, para el caso de que existan fechas repetidas.

Sería algo así. Supongamos que guardamos en el hash %fechas las fechas que estamos viendo. Suponemos también que la fecha de la línea $x la tenemos en $campo[8]. Entonces hacemos un bucle por todo el fichero y hacemos:

De esa manera, vamos creando y aumentando un array, apuntado por el elemento $fechas{$campo[8]}, en donde estarán los números de línea donde aparece esa fecha.

Luego, hacemos un bucle por todas las fechas encontradas, y actuamos según el número de líneas en las que aparece (no probado):

Buenísimo, explorer. Te cuento que ahora la validación de mis datos se hace en menos de un segundo

Ahora el proceso completo de cada archivo se realiza en 1 minuto 45 segundos (ahora es la conversión la que se tarda más)

Te agradezco la ayuda.