Solving this sort of problem can be made much easier if you break it into parts. Use a simple regex to drop words containing doubled letters then you can use a simple regex to find repeated letters.

use warnings;
use strict;

my %words = map {$_ => 1} split ' ', "This will search for words with 
+doubled letters at positions";

print "$_\n" for grep {!/(\w)\1/ && /(\w).+\1/} sort keys %words;
[download]

Prints:

doubled
positions
[download]

G'day Willi,

Firstly, I'd recommend that you move away from the idea of adjusting code whenever search criteria changes: it's tedious, error-prone, and likely to involve many duplications of effort. Instead, write one script that does everything for you.

You've already got a good start in this direction with your letter patterns. In the code below, I changed abCCdEEfgh to ..AA.BB... and ABcBAefghijh to AB.BA.......: I think this makes it a bit clearer without changing the underlying principle. You can also use this for a length check.

The code below shows a technique: you'll need to make some changes to suit your needs. I've added comments that indicate the types of modifications that might be required.

#!/usr/bin/env perl

use 5.010;
use strict;
use warnings;
use autodie;

# Possibly read from command line, database, file, etc.
my @in_patterns = qw{..AA.BB... AB.BA.......};

# Prefer exclusion (blacklist) over inclusion (whitelist).
# Here, exclude proper nouns
#   and any words with non-alphabetic characters.
# Note: in other scenarios, whitelists are better;
#   e.g. only allow access to X, Y & Z.
my $blacklist_re = qr{(?:^[A-Z]|[^A-Za-z])};

# Point to your preferred dictionary. Some on my system:
#my $dict = '/usr/share/dict/words'; # --> linux.words
my $dict = '/usr/share/dict/strine'; # --> australian-english

open my $dict_fh, '<', $dict;

for my $in_pat (@in_patterns) {
    say "*** Input Pattern: $in_pat";

    my $len = length $in_pat;
    my $match_re = '';
    my %seen;
    my $count = 0;

    for my $char (split //, $in_pat) {
        if ($char eq '.') {
            $match_re .= '.';
        }
        elsif (! $seen{$char}) {
            $match_re .= '(.)';
            $seen{$char} = ++$count;
        }
        else {
            $match_re .= "\\$seen{$char}";
        }
    }

    say "*** Match Pattern: $match_re";
    my $qr_re = qr{^$match_re$};
    say "*** QR Regex: $qr_re";

    seek $dict_fh, 0, 0;

    while (<$dict_fh>) {
        chomp;
        next unless length($_) eq $len;
        next if $_ =~ $blacklist_re;
        next unless $_ =~ $qr_re;
        say;
    }
}
[download]

Abridged output:

*** Input Pattern: ..AA.BB...
*** Match Pattern: ..(.)\1.(.)\2...
*** QR Regex: (?^:^..(.)\1.(.)\2...$)
barrelling
barrenness
...
tunnellers
tunnelling
*** Input Pattern: AB.BA.......
*** Match Pattern: (.)(.).\2\1.......
*** QR Regex: (?^:^(.)(.).\2\1.......$)
minimisation
monomaniacal
...
reverberates
secessionist
[download]

/\A (?= [[:alpha:]]{12} \Z) (?! .* (.) \g-1) (?= .* (.) .+ \g-1)/x and print

But if you're scanning a dictionary, don't you know to begin with that all the words are words? It might be faster to scan with
    /\A (?= .{12} \Z) (?! .* (.) \g-1) (?= .* (.) .+ \g-1)/x and print
(OTOH, I know that some dictionaries include apostrophized and hyphenated words, so maybe you need to be specific. (Update: Upon further investigation, I find that the dictionary file I'm using does, indeed, include words like "wristwatch's", so [[:alpha:]]{12} vs. .{12} makes a difference for me.))

Update 1: Note that the regexes above need Perl version 5.10+ to support the \g{n} backreference operator.

Update 2: I second GrandFather's point about splitting up the components of a complex filter regex into individual regexes: they become simpler and easier to understand and manage, In that vein:

c:\@Work\Perl>perl -wMstrict -n -le
"BEGIN { $::n = 0 }
 /\A .{12} \z/x && !/(.) \g-1/x && /(.) .+ \g-1/x
 and ++$::n
 and print;
 END { print \"$::n found\" }
"  ..\moby\mwords\354984si.ngl
[download]

The harder part is to exclude repetition in c..efghijh

... one way is repeated negative look-aheads, another splitting and counting.

We had a similar question just recently: Nonrepeating characters in an RE

You'll find these and many other helpful suggestions discussed there!

HTH! :)

PS:

> abCCdEEfgh ... and D stands for the 6th and 7th letter position

I think you meant E

Posted just to see if it's what you are looking for, since it seems a little unclear (see other replies :)

perl -ne '/^(?!.*(.)\1)(?=.*(.).+\2)(?=.*(?!\2)(.).+\3)\w{12}$/ and pr
+int' /usr/share/dict/words
[download]

This finds 2657 entries in my 'words' file with no adjacent duplicates but at least two different duplicated letters.

I regret to say that I can't figure out how to pm you all individually. So I will do it here.

I want to thank you all for unselfishly volunteering your time and talent to people like me. My query was not for a class assignment or commercial purposes, I am 88 years old and I agitate my brain cells by solving cryptograms. These tools you have given me will aid me in solving the difficult ones. You have given me much to study and I will enjoy doing it. I appreciate your generosity.

Willi