Foro - Perl en Español

Buen día tengan todos en el foro.

Solicito de su amable ayuda. Estoy iniciando en esto del lenguaje de programación Perl con el objetivo de realizar tareas automatizadas y es por ese hecho que me cuesta trabajo entender algunos algoritmos.

En mi tiempo libre leo y complemento la lectura con algoritmos básicos. Aun así me falta mucho para llegar a donde quiero.

Dejando a un lado eso describo mi "problema": Necesito buscar secuencias cortas (alrededor de 20 caracteres) en un archivo plano (txt, fasta o fastq) el cual puede o no contener las secuencias que busco. Ya he realizado este trabajo usando textpad para lo cual en búsqueda pongo la secuencia que deseo buscar y selecciono el archivo donde la va a buscar. Cabe mencionar que son alrededor de 2000 secuencias que debo buscar. Aun así he avanzado en el trabajo en un 30 % o 40 %.

Me ayudaría mucho tener orientación en algoritmos o temas que me ayuden a lo siguiente: quiero que a partir de un archivo secuencias.txt (contiene las secuencias que deseo buscar separadas por saltos de línea) busque en el archivo bibliotecas.txt o .fast o .fastq (contiene información de la secuenciación) las veces que aparece cada una de las secuencias del archivo secuencias.txt y que el resultado lo almacene en un archivo resultado.txt con la misma información del archivo secuencias.txt solo que con el número de veces que aparece separada por espacio o tabulación.

Sé muy bien que es mucho lo que estoy pidiendo pero ya no quiero seguir con el método del textpad pero confío en su ayuda para orientarme a los temas que me ayudarán a resolver mi problema.

Espero haberme explicado bien lo que deseo. De antemano, gracias.

Este es parte del contenido del archivo secuencias.txt

Este es parte del contenido del archivo bibliotecas.txt

Este sería parte del contenido del archivo resultado.txt

Bienvenido a los foros de Perl en Español, pubafra.

No necesitas mucho de algoritmos para resolver un problema tan sencillo como este.

Te vale con leer el archivo secuencias.txt y meter las secuencias como claves de un hash.

Luego abres el archivo bibliotecas.txt, y por cada línea, la comparas con todas las claves del hash. Eso es un bucle por las claves, usando una expresión regular o, mucho mejor, usar la función index(), para saber si la secuencia está en la línea leída de la biblioteca. Por cada aparición de una secuencia, incrementas el valor asociado a ella en el hash.

Te queda abrir el archivo resultado.txt, recorrer las secuencias en el orden en que fueron leídas antes, y por cada una obtienes el número de veces que la has detectado (toda la información está en el hash).

Yo creo que en 20 líneas se puede resolver.

Una forma más óptima sería la confección de un patrón de alternancias con todas las secuencias a buscar, y por medio de una expresión regular, aplicar el patrón a cada línea de la biblioteca. La captura de la cadena encontrada nos sirve de clave dentro del hash para incrementar el número de apariciones. Esto reduce el código unas cinco o seis líneas, pero aumenta su velocidad.

Inténtalo. Si te atascas, te echamos una manita.

explorer, una disculpa de antemano por no haber respondido agradeciendo tu punto de vista para resolver mi problema. No me había reportado ya que me puse a estudiar para realizar al menos un script y presentarlo para corregir errores o mejorarlo por otra forma.

Te comento que resolví por esta vía el problema pero creo que podría mejorar para reducir el tiempo de respuesta. Te muestro el código y espero tus comentarios.

Gracias.

Una forma de acelerarlo es metiendo todas las secuencias en una gigantesca expresión regular, para buscar por todas las secuencias, a la vez, por cada línea de la biblioteca. Y con un hash llevar la cuenta de aparición de cada secuencia.


Ajuste con pos() es necesario, para poder detectar secuencias que pudiesen estar dentro de otras secuencias en la misma línea.

Hola de nuevo, explorer.

Tengo una pregunta: ¿podría buscar las secuencias como líneas del archivo secuencias.txt sin pasar por algún array o hash? En otras palabras: Leer cada una de esas secuencias del archivo.txt y buscarla directamente en bibliotecas.txt y que muestre el mismo resultado.txt.

Ya he intentado varias formas. Una de ellas, que pienso que sería lo correcto, un while() que lea cada línea del secuencias.txt y la almacene en una variable. Después esa variable la paso a una subrutina para que abra el archivo bibliotecas.txt y busque cada variable dentro de la misma subrutina y que imprima en resultado.txt.

No me da resultado y no sé en qué estoy mal, agradecería si me orientas o me das ayuda, gracias.

Bueno, más tarde subo el intento de código.

La forma normal de resolverlo es como dices:

Leer el archivo donde vamos a buscar, línea por línea.
Por cada línea, comparamos esa línea con todas las secuencias, con una expresión regular.
Si el resultado de la comparación es positivo, pues sacamos el resultado.

La solución que te propuse "simplificaba" el segundo paso, construyendo una expresión regular que contuviese todas las secuencias a buscar, por lo que buscamos por todas a la vez. Quizás esta es la parte más oscura.

Aparte de expresiones regulares, otra opción es la de usar index(), que realiza la búsqueda de una cadena dentro de otra, y lo hace un poco más rápido que con exp. reg.

Gracias por tu respuesta, explorer, la voy a estudiar para replantear el programa pero aquí te dejo lo que intenté. Espero me ayudes a resolverlo por esta ruta, gracias.

use warnings;

open (FILE, "sequen5.txt");
open (FILE2, "biblioteca.txt");
open (FILE3, ">>", "resultado2.txt");

## el siguiente bloque extrae palabras en mayúsculas con un
## mínimo de diez letras

while (<FILE>){
while ($_ =~ m/([A-Z]{10,})/g){
$sec = $1;
chomp $sec;
ind_sec(); # le paso cada coincidencia a la subrutina
}
}

## tratando de buscar cada coincidencia en el archivo bibliotecas.txt

sub ind_sec{
$secb = $_;
print $secb;
$count = 0;
while ($sed = <FILE2>){
while ($sed =~ m/$secb/g){
$count += 1;
print;
}
}
print FILE3 "$secb - $count"; # imprime la secuencia y el número de veces que aparece
}

close (FILE);
close (FILE2);
close (FILE3);

exit;

Tienes que reiniciar la búsqueda en biblioteca.txt cada vez que llamas a ind_sec(). Es decir, que debes hacer el open() y el close de FILE2 dentro de esa subrutina.

¿Qué tal, explorer? Gracias por responder.

He avanzado con tu ayuda. Ya tengo este script pero no me sale exactamente el resultado que deseo.

¿Qué variable debo capturar en la expresión regular que se encuentra dentro de la subrutina? Porque $1 la ocupo en la primera expresión regular y al tratar de imprimir junto a $count me sale un error.

Aquí mi avance:
use warnings;

open (FILE, "unicas.txt");

while (<FILE>){
while ($_ =~ m/([A-Z]{10,})/g){
$sec = $1;
chomp $sec;
ind_sec();
}
}


sub ind_sec{
open (FILE2, "datos.txt");
$count = 0;
while ($sed = <FILE2>){
while ($sed =~ m/$sec/g){
$count += 1;
print "$count\n";
}
}
close (FILE2);
}

close (FILE);

exit;

Hay que cambiar un par de cosas:
Entonces, la salida es:

Pero, repito, esto es tremendamente ineficiente. Además, no contemplas el caso de que una secuencia comience dentro de sí misma.

Por ejemplo, si tenemos una secuencia a buscar como

AATAATAATAATAATAAT

resulta que si la buscamos en

AATAATAATAATAATAATAATAATAATAATAATAAT

nos dará que la ha encontrado dos veces, que es lo correcto... ¿o quizás no? Realmente, la secuencia se repite siete veces:
No nos dices si quieres contemplar este caso. Sí, ya sabemos que es casi imposible que se dé, pero...

Este caso es más real: Si buscamos esta secuencia:

GTGAAGTGTGTGAAGTGTG

dentro de

GTGAAGTGTGTGAAGTGTGTGAAGTGTGTGAAGTGTG

¿Cuál debe ser el resultado? Si lo hacemos con tu expresión regular (/$sec/g), nos dirá que solo aparece una vez. Pero... si la buscamos de forma exhaustiva, ¡aparece tres veces!

Esta es mi solución:
La línea que dice OPCIONAL es la que permite hacer una búsqueda exhaustiva, como la del ejemplo que te he puesto. Si crees que no se va a dar ese caso, se puede quitar.

Con un archivo de secuencias como este:
Y con este archivo a analizar (la última línea es la "problemática" )
El resultado es:

Esta solución sigue las mismas ideas que la tuya. Pero sigue siendo menos eficiente que la primera solución que te di, en la que se construye una enorme exp. reg., con lo que se elimina el bucle más interno.