Регулярное выражение в алфавитном порядке с использованием обратных ссылок

Я отправляю этот ответ скорее как комментарий, чем как ответ, поскольку он имеет лучшее форматирование, чем комментарии.

В связи с вашими вопросами:

1. Могу ли я использовать обратные ссылки в своих классах символов для проверки строк в порядке возрастания?

Нет, ты не можешь. Если вы посмотрите раздел регулярные выражения обратной ссылки, вы найдете следующую документацию:

Скобки и обратные ссылки нельзя использовать внутри классов символов

Скобки нельзя использовать внутри классов символов, по крайней мере, в качестве метасимволов. Когда вы помещаете круглую скобку в класс символов, она рассматривается как буквальный символ. Таким образом, регулярное выражение [(a)b] соответствует a, b, ( и ).

Обратные ссылки также нельзя использовать внутри класса символов. \1 в регулярном выражении типа (a)[\1b] — это либо ошибка, либо литерал 1 без необходимости экранируется. В JavaScript это восьмеричный экран.

Относительно вашего 2-го вопроса:

2. Есть ли какое-нибудь менее хакерское решение этой головоломки?

Имхо, ваше регулярное выражение прекрасно, вы могли бы немного сократить его в начале, например так:

(?=^.{5}$)^a*b*c*d*e*f*g*h*i*j*k*l*m*n*o*p*q*r*s*t*u*v*w*x*y*z*$
    ^--- Here

демонстрация регулярных выражений

Если вы хотите использовать Perl (!), это сработает:

/^([a-z])((??{"[$1-z]"}))((??{"[$2-z]"}))((??{"[$3-z]"}))(??{"[$4-z]"})$/

Поскольку кто-то сломал лед, используя Perl, я думаю, что это Perl-решение.

Обратите внимание, что это базовое решение, не связанное с регулярными выражениями, которое
просто помещается в конструкции кода внутри регулярных выражений Perl.
Интересно, что если наступит день, когда вам понадобится синергия
регулярного выражения/кода это хороший выбор.
Тогда возможно, что вместо простого символа [a-z] вы можете
использовать вместо него очень сложный шаблон и использовать проверку против последнего.
Это это сила!!

Регулярное выражение ^(?:([a-z])(?(?{ $last gt $1 })(?!)|(?{ $last = $1 }))){5}$

Perl-код

use strict;
use warnings;


$/ = "";

my @DAry = split /\s+/, <DATA>;

my $last;

for (@DAry)
{
    $last = '';
    if ( 
      /
         ^                             # BOS
         (?:                           # Cluster begin
              ( [a-z] )                     # (1), Single a-z letter
                                            # Code conditional
              (?(?{
                   $last gt $1                  # last > current ?
                })
                   (?!)                          # Fail
                |                              # else,
                   (?{ $last = $1 })             # Assign last = current
              )
         ){5}                          # Cluster end, do 5 times
         $                             # EOS
      /x )
    {
        print "good   $_\n";
    }
    else {
        print "bad    $_\n";
    }
}

__DATA__

aaaaa
abcde
xxyyz
ghost
chips
demos
abCde
xxyyzz
hgost
chps

Выход

good   aaaaa
good   abcde
good   xxyyz
good   ghost
good   chips
good   demos
bad    abCde
bad    xxyyzz
bad    hgost
bad    chps

Ах, ну, это конечное множество, так что вы всегда можете перечислить его с чередованием! Это выдает регулярное выражение «грубой силы» в небольшом REPL Perl:

#include <stdio.h>

int main(void) {
  printf("while (<>) { if (/^(?:");
  for (int a = 'a'; a <= 'z'; ++a)
    for (int b = a; b <= 'z'; ++b)
      for (int c = b; c <= 'z'; ++c) {
        for (int d = c; d <= 'y'; ++d)
          printf("%c%c%c%c[%c-z]|", a, b, c, d, d);
        printf("%c%c%czz", a, b, c);
        if (a != 'z' || b != 'z' || c != 'z') printf("|\n");
      }
  printf(")$/x) { print \"Match!\\n\" } else { print \"No match.\\n\" }}\n");
  return 0;
}

И сейчас:

$ gcc r.c
$ ./a.out > foo.pl
$ cat > data.txt
aaaaa
abcde
xxyyz
ghost
chips
demos
abCde
xxyyzz
hgost
chps
^D
$ perl foo.pl < data.txt
Match!
Match!
Match!
Match!
Match!
Match!
No match.
No match.
No match.
No match.

Регулярное выражение составляет всего 220 КБ или около того ;-)