Expression régulière, lettre utilisée fois/nombre impair impairs

Question

Le titre du fil pourrait être un peu trompeur, mais je n'ai pas trouvé de meilleure façon de le nommer. Je veux trouver un moyen d'utiliser regex pour rechercher des mots qui contiennent seulement les lettres x et y, mais x doit être utilisé un nombre pair et y doit être utilisé avec des nombres impairs.

Answer 1

Je sais comment faire cela avec deux regex.

celui-ci vérifie s'il y a un nombre pair de x (et au moins deux):

/^(y*xy*x)+y*$/ 

Et celui-ci vérifie s'il y a un nombre impair de y (et au moins un):

/^(x*yx*y)*x*yx*$/ 

Les deux correspondront uniquement aux chaînes formées exclusivement de x et y.

Answer 2

Je l'ai testé dans mon éditeur:

(?=([^x]*x[^x]*x[^x]*)*)(?=([^y]*y[^y]*y[^y]*)*[^y]*y[^y]*) 

Cela trouvera sous-chaînes, de sorte que vous pouvez ajouter de l'espace, en commençant, caractères de fin de ligne:

[^\s](?=([^x]*x[^x]*x[^x]*)*)(?=([^y]*y[^y]*y[^y]*)*[^y]*y[^y]*)[$\s] 

Pour le rompre vers le bas, [^x]*x[^x]*x[^x]* saisira tout non-x, jusqu'à ce qu'il trouve le premier x, puis attrape tout ce qui suit non-x jusqu'à ce qu'il trouve le deuxième x, puis saisit à nouveau tout ce qui suit jusqu'à un autre x. Ceci est inclus dans() * afin qu'il soit répété un nombre illimité de fois, de sorte qu'il trouve toutes les paires de x. S'il y a un impair x restant (impair x), l'expression rationnelle ne sera pas capable de correspondre à ce seul x gauche. De même pour le cas y, il correspond à toutes les paires de y, puis s'assure qu'il reste un seul y suivi de tous les non-y. J'ai utilisé? = Pour qu'il corresponde mais ne capture pas, de sorte que nous puissions vérifier x dans la même chaîne pour vérifier y.

Answer 3

Voici une exemple de fonction JavaScript testée implémentant une seule regex répondant à vos besoins. Je suppose que zéro est un nombre (pair) acceptable de X. L'expression régulière est documentée dans un commentaire multi-lignes.

function has_even_X_odd_Y_word(text) { 
/*#!(?#!js\/i re_even_x_odd_y Rev:20170125_2100) 
    # Match word having even count of X and odd count of Y. 
    \b  # Anchor to start of word. 
    # First assert odd, non-zero count of Ys in this word. 
    (?=  # Assert odd count of Y. 
     (?: # Zero or more or more Y pairs. 
     x*y # Optional Xs preceeding 1st Y. 
     x*y # Optional Xs preceeding 2nd Y. 
    )*  # End zero or more Y pairs. 
     x*yx* # Optional Xs around last (odd) Y. 
     \b  # Anchor to end of word. 
    )  # End assert odd count of Y. 
    # Match even number of Xs (can be zero = even). 
    (?:  # Zero or more X pairs. 
     y*x # Optional Ys preceeding 1st X. 
     y*x # Optional Ys preceeding 2nd X. 
    )*  # End zero or more X pairs. 
    y*  # Optional Ys after last (even) X. 
    \b  # Anchor to end of word. 
!#*/ 
    var re_even_x_odd_y = /\b(?=(?:x*yx*y)*x*yx*\b)(?:y*xy*x)*y*\b/i; 
    if (re_even_x_odd_y.test(text)) { return true; } 
    return false; 
} // End has_even_X_odd_Y_word(). 

La fonction retourne true si un mot de correspondance se trouve dans le texte adopté et faux autrement.