Регулярное выражение для строк с четным числом a и odd no of b

Ответ 1

Один из способов сделать это - передать его через два регулярных выражения, удостоверяясь, что они оба совпадают (если вы хотите вообще использовать регулярные выражения, см. ниже альтернативу):

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

Все остальное (и, фактически, даже это), скорее всего, просто попытка быть умной, что обычно является массовым провалом.

Первое регулярное выражение гарантирует, что существует четное число a с b в любом месте микса (до, после и между).

Второй аналогичен, но обеспечивает наличие нечетного числа b в результате стартового a*ba*.

Более лучший способ сделать это - полностью игнорировать регулярные выражения и просто запускать строку следующим образом:

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

Хотя регулярные выражения - прекрасный инструмент, они не подходят для всего, и они становятся гораздо менее полезными, поскольку их читаемость и ремонтопригодность ухудшаются.

Для того, что стоит, однорежимный ответ:

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

но, если я поймал кого-нибудь из моей команды на самом деле, используя такое чудовище, они будут отправлены обратно, чтобы сделать это снова.

Это происходит из бумаги одного Грега Бэкона. См. здесь для фактической внутренней работы.

Ответ 2

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

(Even-Even имеет четное количество Aas и b оба)

Четный а и нечетный b = четный-четный b четный-четный

Это должно работать

Ответ 3

• (bb)*a(aa)*ab(bb)*
• ab(bb)* a(aa)*
• b(aa)*(bb)* .
   .
   .
   .
   .
   ,

может быть много таких регулярных выражений. Есть ли у вас какие-либо другие условия, такие как "начинать с" или что-то в этом роде (кроме нечетных "b" и даже "a" )?

Ответ 4

Я бы сделал следующее:

• regex даже соответствует символу a, затем последовательность b, а затем символ a, затем другая последовательность b, такая, что существует четное число b:

даже → (a (bb) * a (bb) * | a b (bb) * a b (bb) *)

• regex нечетный делает то же самое с нечетным общим числом b:

нечетный → (a b (bb) * a (bb) * | a (bb) * a b (bb) *)

Строка четного числа a и нечетного числа b также:

• начинается с нечетного числа b, а за ним следует четное число нечетных шаблонов даже;
• или начинается с четного числа b, а за ним следует нечетное число нечетных шаблонов даже.

Обратите внимание, что даже не имеет значения для четности/нечетности a/b в строке.

regex → (

b (bb) * даже * (нечетный даже * нечетный) * даже *

|

(bb) * даже * нечетный даже * (нечетный даже * > нечетный) * даже *

)

Конечно, можно заменить каждое появление даже и нечетного в конечном регулярном выражении, чтобы получить одно регулярное выражение.

Легко видеть, что строка, удовлетворяющая этому регулярному выражению, действительно будет иметь четное число a (поскольку символ a встречается только в даже и нечетных подрегесах, и эти каждый использует ровно два а) и нечетное число b (первый случай: 1 b + четное число b + четное число нечетное; второй случай: четное число b + нечетное число нечетное).

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

Ответ 5

Совет высокого уровня: постройте детерминированный конечный автомат для языка --- очень просто, кодируйте четность числа a и b в состояниях, причем q0 кодирует даже nr. a и даже nr. из b s и переход соответственно ---, а затем преобразовать DFA в регулярное выражение (либо с помощью известных алгоритмов для этого, либо "с нуля" ).

Идея здесь заключается в том, чтобы использовать хорошо понятую эквивалентность между DFA (алгоритмическое описание регулярных языков) и регулярными выражениями (алгебраическое описание регулярных языков).

Ответ 6

Это регулярное выражение принимает все строки с четным числом a и четным числом b

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

Теперь, чтобы получить регулярное выражение для четных a и нечетных b

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

Ответ 7

Регулярное выражение приведено ниже:

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

Ответ 8

Для четного числа a и b мы имеем регулярное выражение:

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

Для четного числа a и нечетного числа b все, что нам нужно сделать, это добавить дополнительный b в приведенное выше выражение E

Требуемое регулярное выражение будет:

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

Ответ 9

Структурированный способ сделать это состоит в том, чтобы создать одну диаграмму переходов и построить из нее регулярное выражение. Регулярное выражение в этом случае будет

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

Это выглядит сложно, но охватывает все возможные случаи, которые могут возникнуть.

Ответ 10

ответ (aa + ab + ba + bb) * b (aa + ab + ba + bb) *

Ответ 11

(bb) * b (aa) * + (aa) * b (bb) *

Это ответ, который обрабатывает все типы строк с нечетными b и даже a.

Ответ 12

Если это четное число a, за которым следует нечетное число b (aa) * b (bb) * должен работать

если он в любом порядке (aa) * b (bb) * + b (bb) (aa) должен работать

Ответ 13

Все строки, у которых даже нет и нечетное число из b ((aa + bb) * b (aa + bb) *) + (A + ((a + b) b (a + b)) *)) *

здесь A для нулевой строки. А можно пренебречь.

если есть какая-либо ошибка plz, укажите это.