web-dev-qa-db-fra.com

Expression régulière pour les chaînes avec un nombre pair de a et un nombre impair de b

J'ai du mal à résoudre le problème: - C'est une mission, je l'ai résolu, mais elle semble trop longue et trop vague, quelqu'un peut-il m'aider s'il vous plaît ......

Expression régulière pour les chaînes avec un nombre pair de a et un nombre impair de b où le jeu de caractères = {a, b}.

stringlanguage-theoryregular-language
13
Abu Mathew

Une façon de faire est de le faire passer par deux expressions régulières en s'assurant qu'elles correspondent (en supposant que vous souhaitiez utiliser des expressions régulières, voir ci-dessous une alternative):

^b*(ab*ab*)*$
^a*ba*(ba*ba*)*$

Tout le reste (et même cela) est probablement une tentative d'intelligence, généralement un échec massif.

La première expression régulière garantit qu'il existe un nombre pair de a avec b n'importe où dans le mixage (avant, après et entre les deux).

La seconde est similaire mais assure qu’il existe un impair nombre de b en vertu du a*ba* de départ.

Un moyen lointain mieux de le faire consiste à ignorer complètement les expressions régulières et à simplement parcourir la chaîne comme suit:

def isValid(s):
    set evenA to true
    set oddB to false
    for c as each character in s:
        if c is 'a':
            set evenA to not evenA
        else if c is 'b':
            set oddB to  not oddB
        else:
            return false
    return evenA and oddB

Bien que les expressions régulières soient un outil formidable, elles ne conviennent pas à tout et deviennent de moins en moins utiles à mesure que leur lisibilité et leur maintenabilité se dégradent.

Pour ce que cela vaut, une réponse à une seule expression rationnelle est la suivante:

(aa|bb|(ab|ba)(aa|bb)*(ba|ab))*(b|(ab|ba)(bb|aa)*a)

mais, si je rencontrais quelqu'un dans mon équipe utilisant réellement une monstruosité telle que celle-ci, ils seraient renvoyés pour le refaire.

Cela vient d'un article de Greg Bacon. Voir ici pour le fonctionnement interne réel.

17
paxdiablo
Even-Even = (aa+bb+(ab+ba)(aa+bb)*(ab+ba))*

(Même-Même a un nombre pair d'Aas et de b's)

Même les a et les impairs = Même-Même b Même-Même

Cela fonctionnerait

2
Veenu
  1. (bb)*a(aa)*ab(bb)*
  2. ab(bb)* a(aa)*
  3. b(aa)*(bb)* .
    .
    .
    .
    .
    . 

il peut y avoir beaucoup d'expressions régulières de ce type. Avez-vous une autre condition comme "commencer par un" ou quelque chose du genre (autre que "b" impair et même "a")?

1
vandanak

Pour un nombre pair de a et de b, nous avons regex:

E = { (ab + ba) (aa+bb)* (ab+ba) }*

Pour un nombre pair de a 's et un nombre impair de b' s, il suffit d'ajouter une b supplémentaire dans l'expression ci-dessus E.

La regex requise sera:

E = { ((ab + ba) (aa+bb)* (ab+ba))* b ((ab + ba) (aa+bb)* (ab+ba))* }
0
Abhinav Rastogi

La manière structurée de le faire est de créer un diagramme de transition et de construire l'expression régulière à partir de celui-ci. Dans ce cas, l'expression rationnelle sera

(a((b(aa)*b)*a+b(aa)*ab)+b((a(bb)*a)*b+a(bb)*ba))b(a(bb)*a)*

Cela semble compliqué, mais cela couvre tous les cas possibles.

0
Ricky

Cette expression régulière prend toutes les chaînes avec un nombre pair de a et un nombre pair de b

r1=((ab+ba)(aa+bb)*(ab+ba)+(aa+bb))*

Maintenant, pour obtenir une expression régulière même pour les a et les b impairs

r2=(b+a(aa+bb)*(ab+ba))((ab+ba)(aa+bb)*(ab+ba)+(aa+bb))*
0
Pooja Consul

Les expressions régulières sont données ci-dessous:

    (aa|bb)*((ab|ba)(aa|bb)*(ab|ba)(aa|bb)*b)*
0
rashedcs

Un conseil de haut niveau: construisez un automate fini déterministe pour le langage --- très facile, encodez la parité du nombre de as et bs dans les états, avec q0 encodant même nr. de as et même nr. de bs, et la transition en conséquence ---, puis convertissez le DFA en une expression régulière (en utilisant des algorithmes bien connus pour cela ou "à partir de zéro").

L'idée ici est d'exploiter l'équivalence bien comprise entre le DFA (une description algorithmique des langages normaux) et les expressions régulières (une description algébrique des langages normaux).

0
blazs