වලංගු නිත්‍ය ප්‍රකාශනයක් හඳුනා ගැනීමට නිත්‍ය ප්‍රකාශනයක් තිබේද?

වෙනත් නිත්‍ය ප්‍රකාශනයක් සමඟ වලංගු නිත්‍ය ප්‍රකාශනයක් හඳුනාගත හැකිද? එසේ නම් කරුණාකර පහත උදාහරණ කේතය දෙන්න.

/
^                                             # start of string
(                                             # first group start
  (?:
    (?:[^?+*{}()[\]\\|]+                      # literals and ^, $
     | \\.                                    # escaped characters
     | \[ (?: \^?\\. | \^[^\\] | [^\\^] )     # character classes
          (?: [^\]\\]+ | \\. )* \]
     | \( (?:\?[:=!]|\?<[=!]|\?>)? (?1)?? \)  # parenthesis, with recursive content
     | \(\? (?:R|[+-]?\d+) \)                 # recursive matching
     )
    (?: (?:[?+*]|\{\d+(?:,\d*)?\}) [?+]? )?   # quantifiers
  | \|                                        # alternative
  )*                                          # repeat content
)                                             # end first group
$                                             # end of string
/

මෙය පුනරාවර්තන රීජෙක්ස් වන අතර බොහෝ රීජෙක්ස් එන්ජින් මඟින් සහාය නොදක්වයි. PCRE මත පදනම් වූ අය එයට සහාය විය යුතුය.

හිස් අවකාශය සහ අදහස් නොමැතිව:

/^((?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>)?(?1)??\)|\(\?(?:R|[+-]?\d+)\))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*)$/

.NET පුනරාවර්තනයට සෘජුවම සහාය නොදක්වයි. ( (?1)සහ (?R)ඉදිකිරීම්.) පුනරාවර්තනය සමබර කණ්ඩායම් ගණනය කිරීමකට පරිවර්තනය කළ යුතුය:

^                                         # start of string
(?:
  (?: [^?+*{}()[\]\\|]+                   # literals and ^, $
   | \\.                                  # escaped characters
   | \[ (?: \^?\\. | \^[^\\] | [^\\^] )   # character classes
        (?: [^\]\\]+ | \\. )* \]
   | \( (?:\?[:=!]
         | \?<[=!]
         | \?>
         | \?<[^\W\d]\w*>
         | \?'[^\W\d]\w*'
         )?                               # opening of group
     (?<N>)                               #   increment counter
   | \)                                   # closing of group
     (?<-N>)                              #   decrement counter
   )
  (?: (?:[?+*]|\{\d+(?:,\d*)?\}) [?+]? )? # quantifiers
| \|                                      # alternative
)*                                        # repeat content
$                                         # end of string
(?(N)(?!))                                # fail if counter is non-zero.

සංයුක්ත:

^(?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>|\?<[^\W\d]\w*>|\?'[^\W\d]\w*')?(?<N>)|\)(?<-N>))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*$(?(N)(?!))

අදහස් වලින්:

මෙය ආදේශක සහ පරිවර්තන වලංගු වේද?

එය ආදේශක සහ පරිවර්තනවල රීජෙක්ස් කොටස පමණක් වලංගු කරනු ඇත. s/<this part>/.../

සියලුම වලංගු රීජෙක්ස් ව්‍යාකරණ රීජෙක්ස් සමඟ ගැලපීම න්‍යායාත්මකව කළ නොහැකිය.

රීජෙක්ස් එන්ජිම PCRE වැනි පුනරාවර්තනයට සහය දක්වන්නේ නම් එය කළ හැකි නමුත් එය තවදුරටත් සාමාන්‍ය ප්‍රකාශන ලෙස හැඳින්විය නොහැකිය.

ඇත්ත වශයෙන්ම, “පුනරාවර්තන නිත්‍ය ප්‍රකාශනය” සාමාන්‍ය ප්‍රකාශනයක් නොවේ. නමුත් මෙය රීජෙක්ස් එන්ජින් සඳහා බොහෝ විට පිළිගත් දිගුවකි ... උත්ප‍්‍රාසාත්මක ලෙස, මෙම දීර් re කරන ලද රීජෙක්ස් දිගු කරන ලද රීජෙක්ස් සමඟ නොගැලපේ.

"න්‍යාය අනුව, න්‍යාය සහ භාවිතාව එක හා සමානයි. ප්‍රායෝගිකව ඒවා එසේ නොවේ." නිත්‍ය ප්‍රකාශන පුනරාවර්තනයට සහාය නොදක්වන බව නිත්‍ය ප්‍රකාශන දන්නා සියල්ලන්ම පාහේ දනිති. නමුත් PCRE සහ අනෙකුත් බොහෝ ක්‍රියාත්මක කිරීම් මූලික නිත්‍ය ප්‍රකාශනවලට වඩා බොහෝ සෙයින් සහාය වේ.

grep විධානයෙහි ෂෙල් ස්ක්‍රිප්ට් සමඟ මෙය භාවිතා කිරීමෙන්, එය මට යම් දෝෂයක් පෙන්වයි .. grep: {of වලංගු නොවන අන්තර්ගතය. නිත්‍ය ප්‍රකාශන අඩංගු සියලුම ලිපිගොනු සොයා ගැනීම සඳහා කේත පදනමක් ලබා ගත හැකි පිටපතක් මම සාදමි

මෙම රටාව පුනරාවර්තන නිත්‍ය ප්‍රකාශන ලෙස හැඳින්වෙන දිගුවක් ගසාකයි. රීජෙක්ස් හි පොසික්ස් රසය මෙයට සහාය නොදක්වයි. PCRE රීජෙක්ස් රසය සක්‍රීය කිරීම සඳහා ඔබට -P ස්විචය සමඟ උත්සාහ කළ හැකිය.

Regex ම "සාමාන්‍ය භාෂාවක් නොවන අතර එබැවින් නිත්‍ය ප්‍රකාශනයෙන් විග්‍රහ කළ නොහැක ..."

සම්භාව්‍ය නිත්‍ය ප්‍රකාශන සඳහා මෙය සත්‍ය වේ. සමහර නවීන ක්‍රියාත්මක කිරීම් පුනරාවර්තනයට ඉඩ සලසයි, එමඟින් එය සන්දර්භය රහිත භාෂාවක් බවට පත් කරයි, එය මෙම කාර්යය සඳහා තරමක් වාචික වුවද.

ඔබ ගැලපෙන තැන මට පෙනේ []()/\. සහ වෙනත් විශේෂ රීජෙක්ස් අක්ෂර. විශේෂ නොවන චරිත සඳහා ඔබ ඉඩ දෙන්නේ කොහේද? මෙය ගැලපෙන බව පෙනේ ^(?:[\.]+)$, නමුත් එසේ නොවේ ^abcdefg$. එය වලංගු රීජෙක්ස් එකක්.

[^?+*{}()[\]\\|]වෙනත් ඕනෑම ව්‍යුහයක කොටසක් නොව ඕනෑම තනි අක්ෂරයකට ගැලපේ. (මෙම සත්ය දෙකම ඇතුළත් වේ a- z(සහ ඇතැම් විශේෂ අක්ෂර) ^, $, .).

බලාපොරොත්තු විය නොහැක.

try..catchඔබේ භාෂාව සපයන ඕනෑම දෙයකින් එය තක්සේරු කරන්න.

නැත, ඔබ නිත්‍ය ප්‍රකාශන ගැන තදින් කථා කරන්නේ නම් සහ සන්දර්භය රහිත ව්‍යාකරණ වන නිත්‍ය ප්‍රකාශන ක්‍රියාත්මක කිරීම් ඇතුළත් නොකරන්නේ නම්.

නිත්‍ය ප්‍රකාශනවල එක් සීමාවක් ඇති අතර එමඟින් සියල්ලටම ගැලපෙන සහ රීජෙක්ස් පමණක් ගැලපෙන රීජෙක්ස් ලිවීමට නොහැකි වේ. යුගලනය කර ඇති වරහන් වැනි ක්‍රියාත්මක කිරීම් ඔබට ගැලපෙන්නේ නැත. Regexes එවැනි බොහෝ ඉදිකිරීම් භාවිතා කරයි, අපි []උදාහරණයක් ලෙස ගනිමු. [ගැලපෙන සෑම අවස්ථාවකම ගැලපීමක් තිබිය යුතුය ], එය රීජෙක්ස් සඳහා ප්‍රමාණවත් තරම් සරල ය "\[.*\]".

රීජෙක්ස් හට කළ නොහැකි දෙය නම් ඒවා කූඩු කළ හැකි වීමයි. කැදැලි වරහන් වලට ගැලපෙන රීජෙක්ස් එකක් ලිවිය හැක්කේ කෙසේද? පිළිතුර නම් ඔබට අසීමිත දිගු රීජෙක්ස් නොමැතිව කළ නොහැකි බවයි. තිරිසන් බලය හරහා ඔබට කැදැලි වරහන් ගණන සමඟ සැසඳිය හැකි නමුත් ඔබට කිසි විටෙකත් අත්තනෝමතික ලෙස දිගු කැදැලි වරහන් සමඟ සැසඳිය නොහැක.

මෙම හැකියාව බොහෝ විට ගණන් කිරීම ලෙස හැඳින්වේ, මන්ද ඔබ කැදැල්ලේ ගැඹුර ගණන් කරන බැවිනි. නිර්වචනය අනුව රීජෙක්ස් එකකට ගණන් කිරීමේ හැකියාවක් නැත.

මම මේ ගැන " නිත්‍ය ප්‍රකාශන සීමාවන් " ලිවීම අවසන් කළෙමි .

හොඳ ප්රශ්නයක්.

සැබෑ නිත්‍ය භාෂාවන්ට අත්තනෝමතික ලෙස ගැඹුරින් කැදැලි සහිත හොඳින් සාදන ලද වරහන් තීරණය කළ නොහැක. ඔබේ හෝඩියෙහි අඩංගු වන්නේ නම් '('සහ ')'ඉලක්කය වන්නේ මේවායේ නූල් හොඳින් ගැලපෙන වරහන් වර්‍ග තිබේද යන්න තීරණය කිරීමයි. නිත්‍ය ප්‍රකාශන සඳහා මෙය අත්‍යවශ්‍ය අවශ්‍යතාවයක් වන බැවින් පිළිතුර නැත.

කෙසේ වෙතත්, ඔබ අවශ්‍යතාවය ලිහිල් කර පුනරාවර්තනයක් එකතු කරන්නේ නම් ඔබට එය කළ හැකිය. හේතුව, පුනරාවර්තනය මඟින් මෙම කූඩයට තල්ලු කිරීමෙන් වත්මන් කැදැල්ලේ ගැඹුර "ගණනය කිරීමට" ඉඩ සලසයි.

රස් කොක්ස් විසින් " නිත්‍ය ප්‍රකාශන ගැලපීම සරල හා වේගවත් විය හැකිය " යනුවෙන් ලියා ඇති අතර එය රීජෙක්ස් එන්ජින් ක්‍රියාත්මක කිරීම පිළිබඳ අපූරු නිබන්ධනයකි.

නැත, ඔබ සාමාන්‍ය නිත්‍ය ප්‍රකාශන භාවිතා කරන්නේ නම්.

හේතුව, සාමාන්‍ය භාෂාවන් සඳහා පොම්ප කරන ලෙමාව තෘප්තිමත් කිරීමට ඔබට නොහැකි වීමයි . රැසක් පවතින පවතී නම් භාෂාව "L" අයත් වැලක් නිත්ය බව පොම්ප lemma රාජ්යයන් "N" වැනි බව වැල substrings තුනකට බෙදා පසු x, y, zඑවැනි, |x|>=1 && |xy|<=Nඔබ නැවත නැවත කළ හැකි, yඔබට අවශ්ය පරිදි ඕනෑම වාර ගණනක් සහ සම්පූර්ණ නූල තවමත් අයත් වේ L.

පොම්ප කරන ලෙම්මා හි ප්‍රති consequ ලයක් ලෙස ඔබට නිතිපතා නූල් ස්වරූපයෙන් තිබිය නොහැක a^Nb^Mc^N, එනම් එකම දිගකින් යුත් උපස්ථර දෙකක් වෙනත් නූලකින් වෙන් කරනු ලැබේ. කිසිසේත් ඔබ එවැනි නූල් බෙදී x, yහා z, ඔබ "පොම්ප" බැහැ yමේ අනුව, මුල් භාෂාව හැර "A" සහ "C" වෙනස් අංකය සහිත නූල්, ලබා තොරව. නිදසුනක් ලෙස, වරහන් වර්‍ගවල සාමාන්‍ය ප්‍රකාශන වල තත්වය එයයි.

MizardX විසින් පළ කර ඇති පරිදි පුනරාවර්තන රීජෙක්ස් භාවිතා කිරීමට පරිපූර්ණ ලෙස හැකි වුවද, මේ ආකාරයේ දේවල් සඳහා එය විග්‍රහකයෙකුට වඩා ප්‍රයෝජනවත් වේ. රීජෙක්ස් මුලින් අදහස් කළේ සාමාන්‍ය භාෂාවන් සමඟ භාවිතා කිරීමටය, පුනරාවර්තන වීම හෝ සමතුලිත කණ්ඩායම් තිබීම පැච් එකකි.

වලංගු රීජෙක්ස් නිර්වචනය කරන භාෂාව ඇත්ත වශයෙන්ම සන්දර්භය රහිත ව්‍යාකරණයක් වන අතර එය හැසිරවීම සඳහා ඔබ සුදුසු විග්‍රහයක් භාවිතා කළ යුතුය. සරල රීජෙක්ස් විග්‍රහ කිරීම සඳහා විශ්ව විද්‍යාල ව්‍යාපෘතියක් සඳහා උදාහරණයක් මෙන්න (බොහෝ ඉදිකිරීම් නොමැතිව). එය JavaCC භාවිතා කරයි. ඔව්, අදහස් ස්පා Spanish ් in භාෂාවෙන් ඇත, නමුත් ක්‍රම නම් ස්වයං පැහැදිලි කිරීමකි.

SKIP :
{
    " "
|   "\r"
|   "\t"
|   "\n"
}
TOKEN : 
{
    < DIGITO: ["0" - "9"] >
|   < MAYUSCULA: ["A" - "Z"] >
|   < MINUSCULA: ["a" - "z"] >
|   < LAMBDA: "LAMBDA" >
|   < VACIO: "VACIO" >
}

IRegularExpression Expression() :
{
    IRegularExpression r; 
}
{
    r=Alternation() { return r; }
}

// Matchea disyunciones: ER | ER
IRegularExpression Alternation() :
{
    IRegularExpression r1 = null, r2 = null; 
}
{
    r1=Concatenation() ( "|" r2=Alternation() )?
    { 
        if (r2 == null) {
            return r1;
        } else {
            return createAlternation(r1,r2);
        } 
    }
}

// Matchea concatenaciones: ER.ER
IRegularExpression Concatenation() :
{
    IRegularExpression r1 = null, r2 = null; 
}
{
    r1=Repetition() ( "." r2=Repetition() { r1 = createConcatenation(r1,r2); } )*
    { return r1; }
}

// Matchea repeticiones: ER*
IRegularExpression Repetition() :
{
    IRegularExpression r; 
}
{
    r=Atom() ( "*" { r = createRepetition(r); } )*
    { return r; }
}

// Matchea regex atomicas: (ER), Terminal, Vacio, Lambda
IRegularExpression Atom() :
{
    String t;
    IRegularExpression r;
}
{
    ( "(" r=Expression() ")" {return r;}) 
    | t=Terminal() { return createTerminal(t); }
    | <LAMBDA> { return createLambda(); }
    | <VACIO> { return createEmpty(); }
}

// Matchea un terminal (digito o minuscula) y devuelve su valor
String Terminal() :
{
    Token t;
}
{
    ( t=<DIGITO> | t=<MINUSCULA> ) { return t.image; }
}

preg_matchරීජෙක්ස් වලංගු නොවන්නේ නම් ඔබට රීජෙක්ස් ඉදිරිපත් කළ හැකිය . @වැරදි පණිවිඩ යටපත් කිරීමට භාවිතා කිරීමට අමතක නොකරන්න :

@preg_match($regexToTest, '');

• රීජෙක්ස් නම් 1 නැවත ලබා දෙනු //ඇත.
• රීජෙක්ස් එක හරි නම් 0 නැවත එයි.
• වෙනත් ආකාරයකින් අසත්‍යය නැවත ලබා දෙනු ඇත.

පෝල් මැක්ගුවර්ගේ පහත උදාහරණය, ​​මුලින් පයිපර්සිං විකියෙන්, නමුත් දැන් ලබා ගත හැක්කේ වේබැක් මැෂින් හරහා පමණි , සමහර රීජෙක්ස් විග්‍රහ කිරීම සඳහා ව්‍යාකරණයක් ලබා දෙයි , ගැලපෙන නූල් කට්ටලය නැවත ලබා දීම සඳහා. එනිසා, '+' සහ '*' වැනි අසීමිත පුනරාවර්තන යෙදුම් ඇතුළත් වන ප්‍රති ප්‍රතික්‍ෂේප කරයි. නමුත් එය නැවත සැකසීමේ විග්‍රහයක් සැකසීමේ ආකාරය පිළිබඳ අදහසක් ලබා දිය යුතුය.

# 
# invRegex.py
#
# Copyright 2008, Paul McGuire
#
# pyparsing script to expand a regular expression into all possible matching strings
# Supports:
# - {n} and {m,n} repetition, but not unbounded + or * repetition
# - ? optional elements
# - [] character ranges
# - () grouping
# - | alternation
#
__all__ = ["count","invert"]

from pyparsing import (Literal, oneOf, printables, ParserElement, Combine, 
    SkipTo, operatorPrecedence, ParseFatalException, Word, nums, opAssoc,
    Suppress, ParseResults, srange)

class CharacterRangeEmitter(object):
    def __init__(self,chars):
        # remove duplicate chars in character range, but preserve original order
        seen = set()
        self.charset = "".join( seen.add(c) or c for c in chars if c not in seen )
    def __str__(self):
        return '['+self.charset+']'
    def __repr__(self):
        return '['+self.charset+']'
    def makeGenerator(self):
        def genChars():
            for s in self.charset:
                yield s
        return genChars

class OptionalEmitter(object):
    def __init__(self,expr):
        self.expr = expr
    def makeGenerator(self):
        def optionalGen():
            yield ""
            for s in self.expr.makeGenerator()():
                yield s
        return optionalGen

class DotEmitter(object):
    def makeGenerator(self):
        def dotGen():
            for c in printables:
                yield c
        return dotGen

class GroupEmitter(object):
    def __init__(self,exprs):
        self.exprs = ParseResults(exprs)
    def makeGenerator(self):
        def groupGen():
            def recurseList(elist):
                if len(elist)==1:
                    for s in elist[0].makeGenerator()():
                        yield s
                else:
                    for s in elist[0].makeGenerator()():
                        for s2 in recurseList(elist[1:]):
                            yield s + s2
            if self.exprs:
                for s in recurseList(self.exprs):
                    yield s
        return groupGen

class AlternativeEmitter(object):
    def __init__(self,exprs):
        self.exprs = exprs
    def makeGenerator(self):
        def altGen():
            for e in self.exprs:
                for s in e.makeGenerator()():
                    yield s
        return altGen

class LiteralEmitter(object):
    def __init__(self,lit):
        self.lit = lit
    def __str__(self):
        return "Lit:"+self.lit
    def __repr__(self):
        return "Lit:"+self.lit
    def makeGenerator(self):
        def litGen():
            yield self.lit
        return litGen

def handleRange(toks):
    return CharacterRangeEmitter(srange(toks[0]))

def handleRepetition(toks):
    toks=toks[0]
    if toks[1] in "*+":
        raise ParseFatalException("",0,"unbounded repetition operators not supported")
    if toks[1] == "?":
        return OptionalEmitter(toks[0])
    if "count" in toks:
        return GroupEmitter([toks[0]] * int(toks.count))
    if "minCount" in toks:
        mincount = int(toks.minCount)
        maxcount = int(toks.maxCount)
        optcount = maxcount - mincount
        if optcount:
            opt = OptionalEmitter(toks[0])
            for i in range(1,optcount):
                opt = OptionalEmitter(GroupEmitter([toks[0],opt]))
            return GroupEmitter([toks[0]] * mincount + [opt])
        else:
            return [toks[0]] * mincount

def handleLiteral(toks):
    lit = ""
    for t in toks:
        if t[0] == "\\":
            if t[1] == "t":
                lit += '\t'
            else:
                lit += t[1]
        else:
            lit += t
    return LiteralEmitter(lit)    

def handleMacro(toks):
    macroChar = toks[0][1]
    if macroChar == "d":
        return CharacterRangeEmitter("0123456789")
    elif macroChar == "w":
        return CharacterRangeEmitter(srange("[A-Za-z0-9_]"))
    elif macroChar == "s":
        return LiteralEmitter(" ")
    else:
        raise ParseFatalException("",0,"unsupported macro character (" + macroChar + ")")

def handleSequence(toks):
    return GroupEmitter(toks[0])

def handleDot():
    return CharacterRangeEmitter(printables)

def handleAlternative(toks):
    return AlternativeEmitter(toks[0])


_parser = None
def parser():
    global _parser
    if _parser is None:
        ParserElement.setDefaultWhitespaceChars("")
        lbrack,rbrack,lbrace,rbrace,lparen,rparen = map(Literal,"[]{}()")

        reMacro = Combine("\\" + oneOf(list("dws")))
        escapedChar = ~reMacro + Combine("\\" + oneOf(list(printables)))
        reLiteralChar = "".join(c for c in printables if c not in r"\[]{}().*?+|") + " \t"

        reRange = Combine(lbrack + SkipTo(rbrack,ignore=escapedChar) + rbrack)
        reLiteral = ( escapedChar | oneOf(list(reLiteralChar)) )
        reDot = Literal(".")
        repetition = (
            ( lbrace + Word(nums).setResultsName("count") + rbrace ) |
            ( lbrace + Word(nums).setResultsName("minCount")+","+ Word(nums).setResultsName("maxCount") + rbrace ) |
            oneOf(list("*+?")) 
            )

        reRange.setParseAction(handleRange)
        reLiteral.setParseAction(handleLiteral)
        reMacro.setParseAction(handleMacro)
        reDot.setParseAction(handleDot)

        reTerm = ( reLiteral | reRange | reMacro | reDot )
        reExpr = operatorPrecedence( reTerm,
            [
            (repetition, 1, opAssoc.LEFT, handleRepetition),
            (None, 2, opAssoc.LEFT, handleSequence),
            (Suppress('|'), 2, opAssoc.LEFT, handleAlternative),
            ]
            )
        _parser = reExpr

    return _parser

def count(gen):
    """Simple function to count the number of elements returned by a generator."""
    i = 0
    for s in gen:
        i += 1
    return i

def invert(regex):
    """Call this routine as a generator to return all the strings that
       match the input regular expression.
           for s in invert("[A-Z]{3}\d{3}"):
               print s
    """
    invReGenerator = GroupEmitter(parser().parseString(regex)).makeGenerator()
    return invReGenerator()

def main():
    tests = r"""
    [A-EA]
    [A-D]*
    [A-D]{3}
    X[A-C]{3}Y
    X[A-C]{3}\(
    X\d
    foobar\d\d
    foobar{2}
    foobar{2,9}
    fooba[rz]{2}
    (foobar){2}
    ([01]\d)|(2[0-5])
    ([01]\d\d)|(2[0-4]\d)|(25[0-5])
    [A-C]{1,2}
    [A-C]{0,3}
    [A-C]\s[A-C]\s[A-C]
    [A-C]\s?[A-C][A-C]
    [A-C]\s([A-C][A-C])
    [A-C]\s([A-C][A-C])?
    [A-C]{2}\d{2}
    @|TH[12]
    @(@|TH[12])?
    @(@|TH[12]|AL[12]|SP[123]|TB(1[0-9]?|20?|[3-9]))?
    @(@|TH[12]|AL[12]|SP[123]|TB(1[0-9]?|20?|[3-9])|OH(1[0-9]?|2[0-9]?|30?|[4-9]))?
    (([ECMP]|HA|AK)[SD]|HS)T
    [A-CV]{2}
    A[cglmrstu]|B[aehikr]?|C[adeflmorsu]?|D[bsy]|E[rsu]|F[emr]?|G[ade]|H[efgos]?|I[nr]?|Kr?|L[airu]|M[dgnot]|N[abdeiop]?|Os?|P[abdmortu]?|R[abefghnu]|S[bcegimnr]?|T[abcehilm]|Uu[bhopqst]|U|V|W|Xe|Yb?|Z[nr]
    (a|b)|(x|y)
    (a|b) (x|y)
    """.split('\n')

    for t in tests:
        t = t.strip()
        if not t: continue
        print '-'*50
        print t
        try:
            print count(invert(t))
            for s in invert(t):
                print s
        except ParseFatalException,pfe:
            print pfe.msg
            print
            continue
        print

if __name__ == "__main__":
    main()