Foro - Perl en Español

¡Hola!

Supongamos que tengo un texto al que se han añadido etiquetas morfológicas/sintácticas y otro semejante que hay que etiquetar. Combino ambos textos en formato interlineal, una línea debajo de la otra. Así:




La segunda línea (o sea, el texto sin etiquetar) siempre comienza con el símbolo de espacio y tabulación (para distinguirla de la anterior). Además, pueden ignorarse perfectamente los signos de puntuación, así como la distinción entre mayúsculas y minúsculas y los acentos. Con lo cual, por ejemplo, solo = sólo y Solo = solo. Además de eso, puede darse el caso de que en la primera línea alguna palabra no esté etiquetada.

A partir de esta especie de pseudo-código, y dado que mis conocimientos de Perl son básicos, decido utilizar una serie de expresiones regulares para ir extrayendo las etiquetas con los códigos (siempre entre paréntesis) en la primera línea e insertándolos en la segunda línea, siempre que las palabras sean las mismas.

Mi código actual es este:



Naturalmente, el resultado que desearía obtener es el siguiente:



Mi problema es doble:

1) El script (donde de momento sólo se sustituyen la primera y la segunda palabras) no funciona como yo quisiera, pese a que creo que las expresiones regulares están bien.

2) No estoy convencido de que la forma de abordar el problema (añadiendo toda una serie de expresiones regulares cada vez más largas y complejas) sea la correcta.

¿Alguien podría aconsejarme sobré qué debería hacer o enseñarme algún camino alternativo para optimizar esta tarea?

Muchas gracias.

RGP

1) El problema es que algunos códigos tienen un '-' dentro, así que ese carácter también hay que buscarlo.

2) La solución es encontrar el patrón que sirve para resolver el caso general. Necesitamos capturar palabras que están seguidas por caracteres-palabra-con-guiones encerrados entre paréntesis. La siguiente expresión puede servir: /\b(\w+)\(([-\w]+)\)/, que quiere decir:

• \b es el delimitador de palabra (comienzo o final de palabra)
• capturamos la palabra que le sigue ((\w+))
• seguido por un par de paréntesis (que escapamos con '\')
• y dentro de ellos, uno o más (+) caracteres que pueden ser, o un '-' o un carácter-palabra

Esta solución me funciona a mí:

El proceso es el siguiente:

• vamos leyendo línea a línea
• con la primera línea, extraemos todas las parejas palabras-código y las guardamos en la memoria %codigos
• leemos después la segunda línea (en el mismo bucle que la primera)
• hacemos el proceso de sustitución (s///), de forma repetida (/g), y ejecutando código Perl (/e)
• esta sustitución busca palabras (\w+) y ejecuta el código Perl, que lo que hace es comprobar si existe un código para esa palabra, y si es así, la sustituye. Si no, sustituye la palabra por sí misma.

Esta es otra solución, con una expresión regular que utiliza una versión extendida de patrones especiales:
En este caso, la expresión es:

• \b(\w+)\b es lo mismo que antes: buscamos palabras normales
• (?(?{not defined $codigos{$1}})(*FAIL)) es una comprobación: miramos a ver si la palabra la tenemos en %codigos o no. Si no la tenemos, indicamos un fallo ((*FAIL)) (mejor dicho, indicamos que lo encontrado realmente no era lo que queríamos) y la regex lo intentará con la siguiente palabra.

Seguro que hay más soluciones...

Gracias por la explicación, explorer. Tiene que ser una pasada saber tanto Perl

La primera solución la sigo mejor, aunque hay algo que no me cuadra.

Verás, yo pretendía insertar la etiqueta cuando la palabra en la línea 2 fuera igual que la de la línea 1 y estuviera en la misma posición (p.ej., ambas ocuparan el cuarto lugar). Esto es lo que quería conseguir con mi expresión regular original. Sin embargo, ahora, cuando ejecuto el script observo que "con(P)" en la línea 1 está en cuarto lugar, y en la línea 2, que ha sido etiquetada, en sexto lugar. En este caso no pasa nada porque el resultado es correcto, pero temo que al ocupar distintas posiciones y ejecutar el programa sobre un texto extenso, pueda causarme problemas.

¿Es posible "fijar" la posición de modo que solamente se añadan las etiquetas si la palabra y la posición que ocupan son las mismas?

En ese caso... lo que yo haría sería meter las palabras encontradas en un array (y en otro array, los códigos, ocupando los mismos puestos). Luego, al tratar la segunda línea, la dividimos en palabras (en otro array), y solo queda sacar elemento de cada array.

Si una palabra del primer array le corresponde un código, mira a ver si en el segundo array está la misma palabra. Si no, comienza a buscarla por el resto de palabras del segundo array, y resolvemos. Pero... si agotamos el array, entonces es que algo ha ido mal, y falla.

Gracias. Con un poco de suerte y leyendo mucho supongo que todo esto acabará teniendo sentido. Agradezco de verdad que te hayas tomado la molestia de ayudarme.

Creo que he conseguido encontrar una solución (no ha sido nada fácil).
sale

Un poco de explicación.

Usamos un while() para recorrer las palabras de la primera línea, y un if() para las de la segunda línea. Con el uso de /g podemos hacer esas búsquedas repetidas. Observar (importante) que las dos expresiones regulares están en contexto escalar, por lo que lo que devuelven es un valor booleano (verdadero o falso) sobre si han encontrado la siguiente palabra o no.

Y como extraemos una palabra cada vez, de las dos líneas, estamos seguros de que se cumple la condición de que las palabras deben coincidir en posición.

Si, la primera línea, tenía un código, y las dos palabras son iguales, entonces hacemos la operación de modificación de la segunda línea. En el ejemplo indicado usamos substr(). Pero hay un problema: al usar substr(), las expr. reg. "olvidan" la posición de búsqueda, por lo que se "reiniciaría" la búsqueda de la siguiente palabra desde el comienzo, y no desde el final de la anterior búsqueda. Por eso usamos pos() para almacenar temporalmente esa posición. Después de hacer la inserción del código, ajustamos la posición a la que tenía antes, más lo que ocupa ahora el código.

La líneatambién se puede escribir como


Explicación de las expresiones regulares:

$linea1 =~ m/\G.*?(\w+)(?:\(([-\w]+)\))?/g

De forma repetida (/g), buscamos en $linea1, desde la última posición anterior (\G), cero o más caracteres (.*?) seguidos por una palabra (\w+), que capturaremos, y seguido, opcionalmente seguidas por un par de paréntesis con un código dentro ((?:\(([-\w]+)\))?), de que capturaremos el texto del código.

$linea2 =~ m/\G.*?(\w+)/g

También, de forma repetida (/g), buscamos en $linea2, desde la última posición anterior (\G), cero o más caracteres (.*?) seguidos por una palabra (\w+), que capturaremos.

Los comodines (.*?) son necesarios para saltar los caracteres espacio y de puntuación.

Otra forma de hacer la inserción del código es por medio de una sustitución, pero es algo más lenta (cambiar las líneas 23 a 25 a éstas):

explorer:

¡Estoy realmente impresionado! Lo he probado con un texto más extenso y funciona bien. Lo único es que no añade los códigos si las palabras se diferencian en algún acento (prueba a poner "dia" en lugar de "día") o una palabra está escrita en mayúsculas y la otra en minúsculas (por ej. "madrid" en vez de "Madrid").

¿Existe algún modo de indicar en el script que no tenga en cuenta estos factores y los códigos se inserten igualmente, tal como decía en mi mensaje original, o al tratarse de unicode esto no es posible?

Muchas gracias de nuevo.

RGP

Bueno, la solución está ajustada a que las palabras sean iguales, pero lo que pides ya es un nivel más de profundidad.

Para solucionar el primer caso (tamaño de caja), una solución clásica es la de normalizar las palabras a un mínimo común, por ejemplo, convertir las dos a minúsculas:


pero el problema segundo, el de las tildes, es más peliagudo, porque depende de la codificación que estés usando.

De forma estricta "o" y "ó" son dos letras completamente distintas, así que, hay que hacer alguna transformación de las palabras, para poderlas comparar.

Habría que hacer esto:



aunque... como parece que solo vas a tratar documentación en español, podemos hacer una simplificación: