If you're not strongly committed to using a regex, use something like this (probably will do strange things for non-ascii character sets):

sub hamming {
  my ($x1, $x2) = @_;
  return -1 if length($x1) != length($x2);

  (my $xor = $x1 ^ $x2) =~ tr/\x0//cd;
}

print hamming(@$_), $/
   for [qw[ abcdef abccef ]],
       [qw[ abcdef abc ]],
       [qw[ abcdef abbbbf ]];
__END__
1
-1
3
[download]

# untested
my $target = "abcdef";
my $distance = 1;

my $len = length $target;
my $qr  = qr/ \b(\w{$target})\b (?(??{ hamming($target,$1) < $distance
+ }) | (?!))  /x
[download]

Tell us about the bigger problem. Not your solution, but the problem it solves. For example, could it be that you are trying to search for a word that may be misspelled?

Note that your *{1} syntax is not (Perl) regular expression syntax so it's not clear if you mean 'match any single character' or something else. Rather than an invented (or non-Perl regex) syntax, you should either use a correct Perl regex syntax or a sample of matching and mismatching strings (both would be even better).

The bigger problem... I have a program that allows users to search text files in FASTA format for an arbitrary number of strings of arbitrary length (motifs of DNA nucleotides to be specific). These strings are typically 6-15 characters long.

I have it currently set up to perform the searches with m//g an so on, where I have converted the user input strings into a regexp, based on whether they input only A,C,G, or T, or whether they used standard degeneracies, which allow things like specifying 'R' to mean either 'A' or 'G', etc. So, if the user inputs 'ART', the search string is actually "A[R|A|G]T", and so on. In this context, specifying 'N' at any point is equivalent to [A|C|G|T|N].

What I am looking to do now, is search for whatever user input string, where, in the 5/6 case of my initial example, any 1 character can match N, but the rest of the string must match exactly. Additionally, I am looking to make this an optional feature, not a given of every search, and I want to make the number of N adjustable.

I hope that clarifies things a bit...

Thanks
Matt

Have you looked at Bio::Tools::SeqPattern?

---

Perl is environmentally friendly - it saves trees

   The initial search is done for a word of 
   length "W" that scores at least "T" when 
   compared to the query using a given 
   substitution matrix.

The best solution is not to come up with a single regexp, but have a solution to generate those regexp's. A big benefit: the code will be reusable.

I think the following will do the trick:

my @chars = map quotemeta,
            split //,
            $word;

my $re = join '|',
         map { local @_ = @chars;
               $_[$_] = '.';
               join '', @_
             }
         0..$#chars;
[download]

Using Regexp::Assemble should be faster:

use Regexp::Assemble qw( );

my @chars = map quotemeta,
            split //,
            $word;

my $ra = Regexp::Assemble->new();

for (0..$#chars) {
   local @_ = @chars;
   $_[$_] = '.';
   $ra->add(join '', @_)
}

my $re = $ra->re();
[download]

Generalizing this approach for Hamming distance > 1, using the combinations iterator from Iterating over combinations:

sub gen_regex {
    my ($target, $n) = @_;

    my @chars = split //, $target;
    my $ra    = Regexp::Assemble->new();
    my $iter  = combinations( $n => [ 0 .. $#chars ] );

    while (my @c = $iter->()) {
       local @_ = @chars; 
       $_[$_] = '.' for @c;
       $ra->add( join '', @_ );
    }

    $ra->re();
}
[download]

blokhead