finding probes with one mutation ?

hellworld has asked for the wisdom of the Perl Monks concerning the following question:

Greetings, I'm working on a homework and I'm stuck with a part I just can't figure out. Today I asked another question and managed to solve that part, thanks to all who helped me on that occasion. Now, my problem is that I have printed the two genes I was supposed to find and now I'm supposed to print probes of length 6 with one mutation OF these 2 genes. These probes are supposed to be only explicit content of the 2 genes. A probe can't exist in the whole text and both of the genes. For example, a gene has CACTCT substring in it and that CACTCT should not be existent in the whole text and the other gene. Also CACTCT should have one letter different from the entire text. -mutations- my code is as below:


$infile="input.txt";  

open(IN, "$infile") or die "can'topen \"$infile\"";    

$genom="";

while($line=<IN>)  
{
chomp $line;
$genom.=$line;


}
@allprobes=();
for($x=0;$x<=$alltextlength-6;$x++)
{
$all= substr $genom, $j, 6;
push(@allprobes,$all);

}
@probe=();


while($genom=~m/TATAAT.*?(ATG(...)*?(TAA|TAG|TGA))/g)
{
push (@gen, $1);

}

        $cnt = 0;
        $k=0;
        $m=0;
        
foreach $gen (@gen)
{
$length=length($gen);


    for($j=0; $j<$length-5; $j++)
    {
        $altilik= substr $gen, $j, 6;
        push (@probe,$altilik);



    while($allprobes[$m]=~m/$probe[$k]/g)
    {
        #push (@gen, $1);
        
        $cnt++;
        $k++;
    }
        $m++;

#print "@probe\n\n\n";
#print @allprobes;

    }

}


print "$cnt\n";
[download]

Comment on finding probes with one mutation ? Download Code

Replies are listed 'Best First'.
Re: finding probes with one mutation ? by almut (Canon) on Jun 01, 2009 at 20:38 UTC
...CACTCT should have one letter different from the entire text. One approach would be to replace every position of that sequence with the complementary char set, e.g. `/[^C]ACTCT/` for the first position, and then match those six patterns against the entire text. This should allow you to find all substrings which have one letter different.	[reply] [d/l]
Re^2: finding probes with one mutation ? by Marshall (Canon) on Jun 01, 2009 at 22:13 UTC
Another straight forward approach is to take CACTCT and make a regex like: m/?ACTCT \| C?CTCT \| CA?TCT\| CAC?CT\| CACT?T \| CACTC?/. Update: wrong regex syntax: use . instead of ? Perl is cool in that you can generate regex'es "on the fly". They do not have to be defined during initial compilation. You will be surprised at how fast this can work with Perl 5.10 which has some smart regex enhancements! With this approach you just have to check whether this regex matches or not for all of the other test cases. Not every "OR" in the regex will be evaluated with a smart regex engine. Another way which is more like C would be to XOR each character in the "search" string vs the "test" string. You will get a "false" if they are the same and a "true" if not the same. If you get more than one "true" then the strings are off by more than one. The AGREP (approximate Grep) algorithm has a fancy way to do this. In general I think you will find using the regex engine is faster than using substr especially on later versions of Perl. By all means use substr to make the regex! One of my programs uses some fancy stuff which allows swapping of two letters, letter missing, letter added, and other weird stuff. This "write a program" to analyze the rest of the data approach worked well for me. When you write a regex, you are "writing a program". For example one of the things that my software does is allow "pivoting" around a digit: XY6Z->XZ6Y would be a match. This is possible with the regex engine in Perl, but the regex builder knows that this is a possible thing and instead of super duper fancy regex stuff, I just put an "or" term in the generated regex for XY6Z (i.e. that XZ6Y will match). Update: I've gotten a couple of very helpful suggestions from Perlbotics (THANKS!)..That "." is the right syntax for the regex instead of "?". That is true and corrected above. My program uses a Windows wildcard syntax for the UI (re-write of a legacy program) and I messed up the Perl regex syntax in this post. Another point is that the scheme above will match the original thing that the regex is based upon. I believe that this method from Perlbotics would exclude that: `m/[^C]ACTCT \| C[^A]CTCT \| CA[^C]TCT\| CAC[^T]CT\| CACT[^C]T \| CACTC[^T]/`. My actual code does much more fancy things than just "one character" different. There are things that "pivot around a digit", allow transpositions (ABCD matches ACBD), allows one character insertions and one character deletions and in general some very special rules for how to deal with "thing A is approximately "thing B". My code takes out the "search for" term before returning the results. So this "I will match myself" is not an issue. Anyway the main thrust of this post was that it is possible to create dynamic regex'es and use them in Perl programs. It is possible to simplify what would be horrifically complex Regex's with look ahead and look behind into simple expressions IF you can generate these Regex'es with the Perl program which you can! Of course there is a HUGE amount of application specific stuff here. But think about dynamic regex when appropriate.	[reply] [d/l]
Re: finding probes with one mutation ? by CountZero (Bishop) on Jun 02, 2009 at 07:14 UTC
If you ask homework questions on Perlmonks, the whole idea is not that we write yor homework for you, but rather give you some pointers so you can do it yourself. So, go back to your previous question and the answers you received and then look at your present code and meditate on: the use of "`use strict; use warnings;`" the benefits of the three-argument `open` the use of single quotes against double quotes. These may look like small insignificant things now, but they are likely to save your skin later when you write larger programs. CountZero A program should be light and agile, its subroutines connected like a string of pearls. The spirit and intent of the program should be retained throughout. There should be neither too little or too much, neither needless loops nor useless variables, neither lack of structure nor overwhelming rigidity." - The Tao of Programming, 4.1 - Geoffrey James	[reply] [d/l] [select]