Update: It does work when I get the syntax of the negative lookahead assertion correct. (?!...) not (?!=...)!

Try this:

perl -nle"/^(.)(?!\1)(.)(?!\1|\2)(.)(?!\1|\2|\3)(.)(?!\1|\2|\3|\4)(.)\
+3(?!\1|\2|\3|\4|\5)(.)(?!\1|\2|\3|\4|\5|\6).$/ and print" <words
[download]

Expanded out that regex is:

/^                              ## With the $, exactly 8 chars only
    (.)                         ## Any char as \1
    (?!\1)(.)                   ## Any char as \2 except \1
    (?!\1|\2)(.)                ## Any char as \3 except \1 or \2
    (?!\1|\2|\3)(.)             ## Any char as \4 except ...
    (?!\1|\2|\3|\4)(.)          ## Any char as \5 except ...
    \3                          ## Only whatever is in \3
    (?!\1|\2|\3|\4|\5)(.)       ## Any char as \6 except ...
    (?!\1|\2|\3|\4|\5|\6).      ## Any char except any char we've alre
+ady seen
$/x
[download]

That begs to be generated from some kind of shorthand spec. and actually, you used such a spec in your question.

'ABCDECFG' is a perfect spec. once you think of those letters as placeholders rather than literal characters.

Update: And here is a generator:

#! perl -slw
use strict;

my $spec = shift or die 'No spec supplied!';

my $re = '';
my %tally;
my $i = 1;
for my $c ( split '', $spec ) {
    if( exists $tally{ $c } ) {
        $re .= '\\' . $tally{ $c };
    }
    else {
        if( $i == 1 ) {
            $re .= '(.)';
        }
        else {
            $re .= '(?!' 
                . join( '|', map{ '\\' . $_ } values %tally ) 
                . ')(.)';
        }
        $tally{ $c } = $i++;
    }
}
$re = qr[^$re$];
print $re;

m[$re] and printf $_  while <>;
__END__
C:\test>wordSolver ABCDECFG words
(?-xism:^(.)(?!\1)(.)(?!\1|\2)(.)(?!\1|\3|\2)(.)(?!\1|\4|\3|\2)(.)\3(?
+!\1|\4|\3|\5|\2)(.)(?!\6|\1|\4|\3|\5|\2)(.)$)
abednego
abscised
airborne
...
whisking
worker's
writhing
ziegfeld
[download]

I wonder if the golfers could reduce that to a one-liner?

Tried the very first one. Worked beautifully!

Thank you :)

I don't know about golfing it down, but in terms of presenting a human-readable regex, it would somehow seem more intelligible to me if the whitespace were arranged differently:

/^
  (.)(?!\1)  # any character not followed by itself
  (.)(?!\1|\2)  # any character not followed by itself or previous
  (.)(?!\1|\2|\3)   # likewise unique...
  (.)(?!\1|\2|\3|\4)
  (.)
  \3 (?!\1|\2|\3|\4|\5) # 6th character must be same as 3rd
  (.)(?!\1|\2|\3|\4|\5|\6)  # 7th and 8th must be unique
   .
 $/x
[download]

(Admittedly, it's still a bit of a mind-bender.)

Of course, having that handy regex generator makes the regex formatting and commentary a moot point -- so much nicer to allow people to use the simple "rhyme-scheme" alphabetics for specifying the target pattern, and keep the actual regex syntax a purely "script-internal" detail, hidden from human eyes.

... , but in terms of presenting a human-readable regex, ...

I had 3 attempts at documenting it. The one I presented was the least bad to me, as the programmer that constructed it.

Once you see the pattern, it's pretty clear how it works and how to extend it to other situations. What I attempted to do was make the pattern clear.

But that relates back to a long held belief that the guy that writes the code is the worst possible person to document it. I was fortunate enough to work with the services of a s***-hot technical author (actually 3 over the years, one guy and two women), for a long period. His skill was as much in being able to 'forget' his (self-described, limited) programming skills and so ask questions from the perspective of someone with no knowledge, as it was in his writing. His very capable writing skills, and ability to phrase things clearly and concisely, were just the icing on the cake. His inate ability to tease out the detail that mattered and ignore what I (as programmer, designer or architect) though was important (today, this minute, because I just solved the problem) was far more invaluable.

I highly commend and recommend the idea of adding a competent technical author to any team of more than 5 programmers, if you want your documentation to be produced, on time, on budget and in a usable and useful manner. The salary cost of an English Lit, major with a CS minor and a couple of years of exposure to development environments and technical documentation is approximately the same as a CS grad with one year, post grad experience--but the time they will save you, and the quality it will add to your development processes, are worth several times that.

Pick the right person, with the right mix of 'people skills' and (metaphoric) balls to not take s*** from developers and managers who think that their part of the process is more important than the TAs. And endow them with sufficient authority from the get-go to allow them to 'pull rank' on deadlines, when the nicely, nicely reminders approach fails--and they will be a valuable asset far exceeding their cost.

In a small team that might struggle to find budget for a dedicated TA, you can often find one that will also use their, usually strong organisational and documentary skills, to organise and perform a lot of the day to day housekeeping chores--scheduling, timesheet keeping, minute taking, meeting organisation, checkpoint noting, chasing and documenting; even cardboard programmer(ing?:) when the need arises. In that way, they can allow developers to spend more of their time developing, and less time doing non-programming chores they hate doing and so usually put off until absolutely forced to do them--and then do them badly. Overall, they can be a huge time and money saver. As always with personnel issues, getting the right man or woman for the job is essential.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."

I'm trying to match an 8-character word comprising small letters that has the pattern:

Small letters? do you mean small as in low ASCII code or lowercase?

ABCDECFG

Well, /[A-G]{8}/ should yield true.

The only symbol (letter) that is used twice in the word is "C", which is found only in positions 3 and 6.

That is true for the word you presented. Now what? ... guessing ... maybe you want

$c = substr($_,2,1);
$pat = "\[^$c\]{2}$c\[^$c\]{2}$c\[^$c\]{2}";
print "yup" if /$pat/
[download]

Try again giving us a spec.

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

Hi shmem,

Thanks for trying.

I should have said "lowercase".

I'm looking for a word in a large text that has the following pattern:

abcdecgf

There are 6 unique letters, one is repeated at positions 3 and 6.

I don't know what the word is, so the letter "c" is only an example.

abcdecgf

has 7 unique letters.

A single regexp would be too convoluted I guess (I say that only because such a regexp is beyond my skills :-) update: or laziness :-)

#!/usr/bin/perl -nl
if (length == 8) {
  $c = substr ($_, 2, 1);
  if (substr ($_, 5, 1) eq $c) {
    my %h;
    @h{split//,$_} = (1) x 8;
    print if keys %h == 7; 
  }
}
__END__
perl match.pl /usr/share/dict/words
Abednego
abscised
Acadians
Acadia's
Acalia's
acerbest
Adaiha's
Adalia's
Adelbert

...

whirling
whisking
Wieche's
wielders
Winton's
worker's
writhing
Yahweh's
Yeargain
Ygerne's
Yorker's
Zarger's
Ziegfeld
[download]

update: changed to -nl to apply on /usr/share/dict/words

--shmem

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

abcdecgf

There are 6 unique letters, one is repeated at positions 3 and 6.

There must be 7! (No, not seven factorial...)

I don't know what the word is, so the letter "c" is only an example.

Are the positions fixed too? I'm assuming they are, since the problem is slightly more complex like that. Of course there are tons of ways to do it. And as shmem wrote, probably not best done with a single regex - although it may be possible, perhaps by means of one of those funky extensions still marked as "experimental". One possible way that springs to my mind is:

#!/usr/bin/perl

use strict;
use warnings;

$_=<<'.';
bEjhMELGUaL smtMDEYSxyDvuQiUfAbJfYMPnfJAqaPnKL VWZWSdfYRSaSGlXOyPfxusC
dtRAHabcdecgf taNdvtKdBlJcnFryVXObEDvawRyviWO hwlKiBpDWYeBPYhlpKFvrSeQ
ksWmkXqQdLQPIzvKFE Jqrclq mPqQbMvkAx LtVuFMehKirSATuqlFzqwRknocsrcKXAE
FNbOivdvkRonEkg apuPyHpTlssvVs BbwiHBvhfrSFwVkhwHkvoYjaGgntzFbEvPCIttD
IAlYqoLUjtxsYvbwUBHIoMYmPJbGeXymuwERkHwSyKbE XMCcFgsYPzmJbVUsOwfDTgUiJ
.

while (/(?=([a-zA-Z]{8}))/g) {
    my @l = (my $found=$1) =~ /./g;
    print $found, "\n" if $l[2] eq $l[5] and do {
        my %h; @h{@l}=(); 7 == keys %h;
    }
}
  
__END__
[download]

Update: or, in a slightly more agile way:

for (/(?=([A-zA-Z]{8}))/g) {
    my @l=/./g;
    print $_, "\n" if $l[2] eq $l[5] and do {
        my %h; @h{@l}=(); 7 == keys %h;
    }
}
[download]

/^([a-z])(?!.*\1)  # letter, never followed by the same letter
  ([a-z])(?!.*\2)  # another
  ([a-z])(?=(?!\3).(?!\3).\3(?!.*\3))    # letter followed by two othe
+rs, then itself and never again
  ([a-z])(?!.*\4)  # another of the first type
  ([a-z])(?!.*\5)  # another
  \3               # the repeated char
  ([a-z])(?!\6)    # another unique char
  ([a-z])\z        # final char
/x;
[download]

Thanks Roy Johnsonf.

I ran your code against the dict file containing words with length 8. I didn't get any results - I'm suspecting maybe the word required by the regex doesn't exist.

#   A    B     C     D    E   C  F    G
m/[a-z][a-z]([a-z])[a-z][a-z]\1[a-z][a-z]/
[download]

Thanks ArchFool.

I had something like yours. It produced results with other repeated symbols (letters) than the ones at positions 3 and 6.

Erm . . . /ABCDECFG/

Try reading How (Not) To Ask A Question and see if you can't ask a clearer question.