web-dev-qa-db-ger.com

Regulärer Ausdruck für Strings mit gerader Zahl von a und ungerade von b

Ich habe ein Problem bei der Lösung des Problems: - Es ist eine Aufgabe, ich habe es gelöst, aber es scheint zu lang und vage zu sein. Kann mir bitte jemand helfen ......

Regulärer Ausdruck für die Strings mit gerader Anzahl von a und ungeraden Anzahl von b, wobei der Zeichensatz = {a, b} ist.

13
Abu Mathew

Eine Möglichkeit, dies zu tun, besteht darin, es durch two reguläre Ausdrücke zu übergeben, um sicherzustellen, dass beide übereinstimmen (vorausgesetzt, Sie möchten überhaupt reguläre Ausdrücke verwenden, siehe unten für eine Alternative):

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

Alles andere (und in der Tat sogar das) ist höchstwahrscheinlich nur ein Versuch, klug zu sein, der im Allgemeinen ein massiver Misserfolg ist.

Der erste reguläre Ausdruck stellt sicher, dass es eine gerade Anzahl von a mit b an einer beliebigen Stelle im Mix gibt (davor, danach und dazwischen).

Die zweite ist ähnlich, stellt jedoch sicher, dass es eine odd - Nummer von b gibt, und zwar aufgrund des Starts von a*ba*.


Ein weit besser Weg, dies zu tun, besteht darin, reguläre Ausdrücke vollständig zu ignorieren und einfach den String wie folgt auszuführen:

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

Obwohl reguläre Ausdrücke ein wunderbares Werkzeug sind, eignen sie sich nicht für alles und sie werden viel weniger nützlich, da ihre Lesbarkeit und Wartbarkeit abnehmen.


Für was es wert ist, ist eine Antwort mit einem einzigen Ausdruck:

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

aber wenn ich jemanden in meinem Team mit einer solchen Monstrosität erwischt hätte, würden sie zurückgeschickt, um es erneut zu tun.

Dies stammt aus einem Artikel von einem Greg Bacon. Sehen Sie hier für das tatsächliche Innenleben.

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

(Even-Even hat gerade Anzahl von Aas und b beide)

Sogar a's und ungerade b's = Even-Even b Even-Even

Das sollte funktionieren

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

es kann viele solcher regulärer Ausdrücke geben. Haben Sie eine andere Erkrankung wie "mit a beginnen" oder etwas Ähnliches (außer ungerade 'b' und sogar 'a')?

1
vandanak

Für gerade Anzahl von a und b haben wir Regex:

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

Für eine gerade Anzahl von aname __s und eine ungerade Anzahl von bname __s müssen wir lediglich einen zusätzlichen bim obigen Ausdruck Ehinzufügen.

Die erforderliche Regex ist:

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

Der strukturierte Weg besteht darin, ein Übergangsdiagramm zu erstellen und daraus den regulären Ausdruck zu erstellen. Der Regex wird in diesem Fall sein

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

Es sieht kompliziert aus, deckt aber alle möglichen Fälle ab.

0
Ricky

Dieser reguläre Ausdruck nimmt alle Zeichenfolgen mit einer geraden Anzahl von a und einer geraden Anzahl von b an

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

Jetzt einen regulären Ausdruck für gerade As und ungerade B erhalten

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

Die regulären Ausdrücke sind unten angegeben:

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

Ein übergeordneter Ratschlag: Konstruieren Sie einen deterministischen endlichen Automaten für die Sprache - sehr einfach, codieren Sie die Parität der Anzahl von as und bs in den Status, mit q0 sogar nr. von as und sogar nr. von bs und dementsprechend dem Übergang --- und dann den DFA in einen regulären Ausdruck umwandeln (entweder mit bekannten Algorithmen oder "von Grund auf").

Die Idee hier ist, die allgemein bekannte Äquivalenz zwischen dem DFA (eine algorithmische Beschreibung regulärer Sprachen) und den regulären Ausdrücken (einer algebraischen Beschreibung regulärer Sprachen) auszunutzen.

0
blazs

Ich würde wie folgt vorgehen:

  • regex gerade entspricht dem Symbol a, dann eine Folge von b, dann das Symbol a wieder, dann eine andere Folge von b, so dass es eine gerade Anzahl von b gibt:

gerade -> ( a ( bb) * a ( bb ) * | a b ( b) * a b ( bb) *)

  • regex ngerade macht dasselbe mit einer ungeraden Gesamtzahl von b 's:

ngerade -> ( a b ( bb) * a ( bb) * | a ( bb) * a b ( bb) *)

Ein String mit einer geraden Anzahl von a und einer ungeraden Anzahl von b ist entweder:

  • beginnt mit einer ungeraden Anzahl von b, gefolgt von einer geraden Anzahl von ngeraden Mustern unter geraden Mustern;
  • oder beginnt mit einer geraden Anzahl von b und gefolgt von einer ungeraden Anzahl von ngeraden Mustern unter geraden Mustern.

Beachten Sie, dass gerade keinen Einfluss auf die Ebenheit/Seltsamkeit der a/ b in der Zeichenfolge hat.

regex -> (

b ( bb) * gerade * (ngeradegerade *ngerade) * gerade *

|

( bb) * gerade *ngeradegerade * (ngerade - gerade *ngerade) * gerade *

)

Natürlich kann man jedes Vorkommen von gerade und ngerade im endgültigen regulären Ausdruck ersetzen, um einen einzelnen regulären Ausdruck zu erhalten.

Es ist leicht zu erkennen, dass eine Zeichenfolge, die diesen regulären Ausdruck erfüllt, tatsächlich eine gerade Anzahl von a (als Symbol a aufweist und nur in vorkommt. gerade und ngerade Unterausdrücke, und diese verwenden jeweils genau zwei a 's) und eine ungerade Anzahl von b' s (erster Fall: 1 b + gerade Anzahl b + gerade Anzahl ngerade; Zweiter Fall: gerade Anzahl von b + ungerade Anzahl von ngerade).

Eine Zeichenfolge mit einer geraden Anzahl von a und einer ungeraden Anzahl von b erfüllt diese Regex, da sie mit null oder mehr beginnt b 's, dann folgt [eins a, null oder mehr b' s, eins mehr a und null oder mehr b 's], null oder mehrmals.

0
Fabian Pijcke