У популярній (і найважливішій) книзі з інформатики «Вступ до формальних мов та автоматів » Пітера Лінца часто зазначається така формальна мова:

головним чином через те, що цю мову не можна обробити автоматами з кінцевим станом. Цей вираз означає "Мова L складається з усіх рядків 'a', за якими 'b', в яких кількість 'a' і 'b' є рівними і не нульовими".

Виклик

Напишіть робочу програму / функцію, яка отримує рядок, що містить лише "a" і "b" s , як введення та повернення / виведення значення істинності , кажучи, що ця строка є дійсною формальною мовою L.

• Ваша програма не може використовувати будь-які зовнішні інструменти обчислення, включаючи мережу, зовнішні програми тощо. Оболонки - виняток із цього правила; Bash, наприклад, може використовувати утиліти командного рядка.

• Ваша програма повинна повернути / вивести результат "логічним" способом, наприклад: повернення 10 замість 0, "звуковий сигнал", виведення в режим stdout тощо. Докладніше тут.

• Діють стандартні правила гольф-коду.

Це код-гольф . Виграє найкоротший код у байтах. Удачі!

Пробні кейси Truthy

"ab"
"aabb"
"aaabbb"
"aaaabbbb"
"aaaaabbbbb"
"aaaaaabbbbbb"

Фальшиві тестові справи

""
"a"
"b"
"aa"
"ba"
"bb"
"aaa"
"aab"
"aba"
"abb"
"baa"
"bab"
"bba"
"bbb"
"aaaa"
"aaab"
"aaba"
"abaa"
"abab"
"abba"
"abbb"
"baaa"
"baab"
"baba"
"babb"
"bbaa"
"bbab"
"bbba"
"bbbb"

MATL , 5 4 байти

tSP-

Друкує не порожній масив розміром 1 с, якщо рядок належить до L , а порожній масив або масив з 0 с (обидва помилкові) в іншому випадку.

Дякуємо @LuisMendo за те, що виграли 1 байт!

Спробуйте в Інтернеті!

Як це працює

t      Push a copy of the implicitly read input.
 S     Sort the copy.
  P    Reverse the sorted copy.
   -   Take the difference of the code point of the corresponding characters
       of the sorted string and the original.

Python 3, 32 байти

eval(input().translate(")("*50))

Вихідні дані за допомогою коду виходу : Помилка помилкової, помилки немає.

Рядок оцінюється як код Python, замінюючи паролі (для aі )для b. Тільки вирази форми a^n b^nстають добре сформованими виразами круглих дужок, як ((())), оцінюючи до кортежу ().

Будь-які невідповідні паролі дають помилку, як і кілька груп, як (()()), наприклад , немає роздільника. Порожній рядок також виходить з ладу (це вдалося б досягти exec).

Перетворення ( -> a, ) -> bздійснюється з допомогою str.translate, яка замінює символи , як показано на рядок , яка служить в якості таблиці перетворення. Враховуючи рядок довжиною 100 ") (" * 50, таблиці відображають перші 100 значень ASCII як

... Z[\]^_`abc
... )()()()()(

яка приймає ( -> a, ) -> b. У Python 2 повинні бути передбачені перетворення для всіх 256 значень ASCII, що вимагає на "ab"*128один байт довше; завдяки isaacg за вказівку на це.

Сітківка , 12 байт

Подяка FryAmTheEggman, який знайшов це рішення самостійно.

+`a;?b
;
^;$

Друкує 1для дійсного введення та 0іншим чином.

Спробуйте в Інтернеті! (Перший рядок включає тестовий набір, відокремлений виведенням ліній.)

Пояснення

Групи врівноваження вимагають дорогого синтаксису, тому натомість я намагаюся зменшити допустимий вклад до простої форми.

1 етап

+`a;?b
;

+Каже Retina повторити цей етап в циклі , поки на виході не перестає змінюватися. Він відповідає abабо a;bзамінює його або замінює ;. Розглянемо кілька випадків:

• Якщо as і bs в рядку не врівноважуються так, як (і )зазвичай потрібно, деякі aабо bзалишаться в рядку, оскільки baабо b;aне можуть бути вирішені, і окремі, aабо bсамостійно не можуть або. Щоб позбутися всіх as і bs, має бути один відповідний bправоруч від кожного a.
• Якщо і aі bне всі вкладені (наприклад, якщо у нас є щось на кшталт ababабо aabaabbb), тоді ми закінчимося декількома ;(і, можливо, деякими as і bs), тому що в першій ітерації знайдеться декілька abs, щоб вставити їх, і подальші ітерації збережуть кількість ;рядка.

Отже, якщо і лише якщо вхід має форму , ми закінчимося одиничним у рядку.anbn;

Етап 2:

^;$

Перевірте, чи не містить отриманий рядок нічого, окрім крапки з комою. (Коли я кажу "перевірити", я фактично маю на увазі, підрахуйте кількість збігів даного регулярного виразу, але оскільки цей регулярний вираз може збігатися щонайменше за рахунок якорів, це дає або 0або 1.)

Haskell, 31 байт

f s=s==[c|c<-"ab",'a'<-s]&&s>""

Зрозуміння списку [c|c<-"ab",'a'<-s]складає рядок по одному 'a'для кожного 'a'з s, а потім по одному 'b'для кожного 'a'в s. Це дозволяє уникнути підрахунку шляхом зіставлення на константі та отримання результату для кожного матчу.

Цей рядок перевіряється рівним початковому рядку, а початковий рядок - не порожнім.

Грим , 12 байт

A=\aA?\b
e`A

Спробуйте в Інтернеті!

Пояснення

Перший рядок визначає нетермінальний A, який відповідає одній букві a, можливо, нетермінальній A, а потім одній букві b. Другий рядок відповідає усьому входу ( e) проти нетерміналу A.

8-байт неконкурентна версія

e`\a_?\b

Написавши першу версію цієї відповіді, я оновив Grime, щоб вважати _ім'ям виразу вищого рівня. Це рішення рівнозначне вище, але уникає повторення етикетки A.

Брахілог , 23 19 байт

@2L,?lye:"ab"rz:jaL

Спробуйте в Інтернеті!

Пояснення

@2L,                  Split the input in two, the list containing the two halves is L
    ?lye              Take a number I between 0 and the length of the input              
        :"ab"rz       Zip the string "ab" with that number, resulting in [["a":I]:["b":I]]
               :jaL   Apply juxtapose with that zip as input and L as output
                        i.e. "a" concatenated I times to itself makes the first string of L
                        and "b" concatenated I times to itself makes the second string of L

05AB1E , 9 байт

Код:

.M{J¹ÔQ0r

Пояснення:

.M         # Get the most frequent element from the input. If the count is equal, this
           results into ['a', 'b'] or ['b', 'a'].
  {        # Sort this list, which should result into ['a', 'b'].
   J       # Join this list.
    Ô      # Connected uniquified. E.g. "aaabbb" -> "ab" and "aabbaa" -> "aba".
     Q     # Check if both strings are equal.
      0r   # (Print 0 if the input is empty).

Останні два байти можна відкинути, якщо вхід гарантовано не порожній.

Використовує кодування CP-1252 . Спробуйте в Інтернеті! .

Желе , 6 байт

Ṣ=Ṛ¬Pȧ

Друкує сам рядок, якщо він належить до L або порожній, а 0 в іншому випадку.

Спробуйте в Інтернеті! або перевірити всі тестові випадки .

Як це працює

Ṣ=Ṛ¬Pȧ  Main link. Argument: s (string)

Ṣ       Yield s, sorted.
  Ṛ     Yield s, reversed.
 =      Compare each character of sorted s with each character of reversed s.
   ¬    Take the logical NOT of each resulting Boolean.
    P   Take the product of the resulting Booleans.
        This will yield 1 if s ∊ L or s == "", and 0 otherwise.
     ȧ  Take the logical AND with s.
       This will replace 1 with s. Since an empty string is falsy in Jelly,
       the result is still correct if s == "".

Альтернативна версія, 4 байти (неконкурентна)

ṢnṚȦ

Друкує 1 або 0 . Спробуйте в Інтернеті! або перевірити всі тестові випадки .

Як це працює

ṢnṚȦ  Main link. Argument: s (string)

Ṣ     Yield s, sorted.
  Ṛ   Yield s, reversed.
 n    Compare each character of the results, returning 1 iff they're not equal.
   Ȧ  All (Octave-style truthy); return 1 if the list is non-empty and all numbers
      are non-zero, 0 in all other cases.

J, 17 байт

#<.(-:'ab'#~-:@#)

Це правильно працює для надання фальси для порожнього рядка. Помилка - фальсифікація.

Старі версії:

-:'ab'#~-:@#
2&#-:'ab'#~#   NB. thanks to miles

Доведення та пояснення

Основне дієслово - це виделка, що складається з цих трьох дієслів:

# <. (-:'ab'#~-:@#)

Це означає: "Менша <.довжина ( #) і результат правильного зубця ( (-:'ab'#~-:@#))".

Правий зубчик - це 4-поїзд , що складається з:

(-:) ('ab') (#~) (-:@#)

Нехай kпредставить наш вклад. Тоді це еквівалентно:

k -: ('ab' #~ -:@#) k

-:є оператором сірника, тому провідні -:тести на інваріантність під монадійною вилкою 'ab' #~ -:@#.

Оскільки лівий зубчик вилки є дієсловом, він стає постійною функцією. Отже, вилка еквівалентна:

'ab' #~ (-:@# k)

Правий зубчик половини вилки ( -:) довжини ( #) k. Дотримуйтесь #:

   1 # 'ab'
'ab'
   2 # 'ab'
'aabb'
   3 # 'ab'
'aaabbb'
   'ab' #~ 3
'aaabbb'

Зараз це стосується kлише дійсних входів, тому ми тут зробили. #помилки для рядків непарної довжини, які ніколи не задовольняють мову, тому ми теж робимо це.

У поєднанні з меншою довжиною і цим порожній рядок, який не є частиною нашої мови, дає свою довжину 0, і ми все з цим робимо.

Bison / YACC 60 (або 29) байт

(Ну, компіляція для програми YACC - це кілька кроків, тому, можливо, потрібно включити деякі для цього. Детальніше див. Нижче.)

%%
l:c'\n';
c:'a''b'|'a'c'b';
%%
yylex(){return getchar();}

Функція повинна бути досить очевидною, якщо ви знаєте її інтерпретувати з точки зору формальної граматики. Аналізатор приймає abабо aдотримується будь-яку прийнятну послідовність, за якою слідує a b.

Ця реалізація покладається на компілятор, який приймає семантику K&R, щоб втратити кілька символів.

Це важче, ніж я хотів би, якщо потрібно визначитись yylexі зателефонувати getchar.

Компілювати з

$ yacc equal.yacc
$ gcc -m64 --std=c89 y.tab.c -o equal -L/usr/local/opt/bison/lib/ -ly

(більшість варіантів gcc є специфічними для моєї системи і не повинні рахуватися з кількістю байтів; ви можете порахувати, -std=c89що додає 8 до переліченого значення).

Бігайте з

$ echo "aabb" | ./equal

або еквівалент.

Значення правдивості повертається в ОС, а помилки також повідомляються syntax errorв командному рядку. Якщо я можу порахувати лише ту частину коду, яка визначає функцію синтаксичного аналізу (тобто нехтування другою %%та всім, що випливає далі), я отримую підрахунок 29 байт.

Perl 5.10, 35 17 байт (з прапором -n )

say/^(a(?1)?b)$/

Переконайтеся, що рядок починається з as, а потім повторюється на bs. Він відповідає лише в тому випадку, якщо обидві довжини рівні.

Дякую Мартіну Ендеру, що вдвічі зменшив кількість байтів і навчив мене трохи про рекурсію в регулярних виразах: D

Він повертає весь рядок, якщо він відповідає, і нічого, якщо ні.

Спробуйте тут!

JavaScript, 54 55 44

s=>s&&s.match(`^a{${l=s.length/2}}b{${l}}$`)

Побудує простий регулярний вираз на основі довжини рядка і тестує його. Для довжини 4 рядка ( aabb) регулярний вигляд виглядає так:^a{2}b{2}$

Повертає значення truthy або falsey.

11 байт збережено завдяки Нілу.

f=s=>s&&s.match(`^a{${l=s.length/2}}b{${l}}$`)
// true
console.log(f('ab'), !!f('ab'))
console.log(f('aabb'), !!f('aabb'))
console.log(f('aaaaabbbbb'), !!f('aaaaabbbbb'))
// false
console.log(f('a'), !!f('a'))
console.log(f('b'), !!f('b'))
console.log(f('ba'), !!f('ba'))
console.log(f('aaab'), !!f('aaab'))
console.log(f('ababab'), !!f('ababab'))
console.log(f('c'), !!f('c'))
console.log(f('abc'), !!f('abc'))
console.log(f(''), !!f(''))

C, 57 53 байт

t;x(char*s){t+=*s%2*2;return--t?*s&&x(s+1):*s*!1[s];}

Старе рішення, що має 57 байт:

t;x(char*s){*s&1&&(t+=2);return--t?*s&&x(s+1):*s&&!1[s];}

Укладено з gcc v. 4.8.2 @Ubuntu

Дякую угорен за поради!

Спробуйте це на Ideone!

Сітківка , 22 байти

Ще одна коротша відповідь тією ж мовою щойно прийшла ...

^(a)+(?<-1>b)+(?(1)c)$

Спробуйте в Інтернеті!

Це демонстрація врівноважувальних груп у регексе, яку повністю пояснює Мартін Ендер .

Оскільки моє пояснення не наблизиться до його половини, я просто посилаюся на нього і не намагаюся пояснити, оскільки це буде шкодити славі його пояснення.

Befunge-93, 67 байт

0v@.<  0<@.!-$<  >0\v
+>~:0`!#^_:"a" -#^_$ 1
~+1_^#!-"b" _ ^#`0: <

Спробуйте тут! Можна пояснити, як це працює пізніше. Можна також спробувати пограти в гольф лише на трохи більше, тільки для ударів.

MATL , 9 байт

vHI$e!d1=

Спробуйте в Інтернеті!

Вихідний масив є truthy, якщо він не порожній, і всі його записи ненульові. Інакше це хибність. Ось кілька прикладів .

v     % concatenate the stack. Since it's empty, pushes the empty array, []
H     % push 2
I$    % specify three inputs for next function
e     % reshape(input, [], 2): this takes the input implicitly and reshapes it in 2
      % columns in column major order. If the input has odd length a zero is padded at
      % the end. For input 'aaabbb' this gives the 2D char array ['ab;'ab';'ab']
!     % transpose. This gives ['aaa;'bbb']
d     % difference along each column
1=    % test if all elements are 1. If so, that means the first tow contains 'a' and
      % the second 'b'. Implicitly display

машинний код x86, 29 27 байт

Hexdump:

33 c0 40 41 80 79 ff 61 74 f8 48 41 80 79 fe 62
74 f8 0a 41 fe f7 d8 1b c0 40 c3

Код складання:

    xor eax, eax;
loop1:
    inc eax;
    inc ecx;
    cmp byte ptr [ecx-1], 'a';
    je loop1;

loop2:
    dec eax;
    inc ecx;
    cmp byte ptr [ecx-2], 'b';
    je loop2;

    or al, [ecx-2];
    neg eax;
    sbb eax, eax;
    inc eax;
done:
    ret;

Ітераціює на aбайтах спочатку, потім над наступними 'b' байтами. Перша петля збільшує лічильник, а друга петля зменшує її. Згодом робить біт АБО між наступними умовами:

1. Якщо в кінці лічильника немає 0, рядок не збігається
2. Якщо байт, що відповідає послідовності bs, не дорівнює 0, рядок також не відповідає

Потім, він повинен "перевернути" значення істини в eax- встановити його на 0, якщо воно не було 0, і навпаки. Виявляється, що найкоротший код для цього - це наступний 5-байтний код, який я вкрав з виводу мого компілятора C ++ для result = (result == 0):

    neg eax;      // negate eax; set C flag to 1 if it was nonzero
    sbb eax, eax; // subtract eax and the C flag from eax
    inc eax;      // increase eax

Рубін, 24 байти

eval(gets.tr'ab','[]')*1

(Це просто геніальна ідея Xnor у рубіновій формі. Інша моя відповідь - це рішення, яке я насправді придумав сам.)

Програма приймає вхідні дані , перетворює aі bдо [і , ]відповідно, і оцінює його.

Дійсний вхід сформує вкладений масив, і нічого не станеться. Неврівноважений вираз призведе до краху програми. У Ruby порожній вхід оцінюється як nil, який вийде з ладу, оскільки nilне визначив *метод.

Sed, 38 + 2 = 40 байт

s/.*/c&d/;:x;s/ca(.*)bd/c\1d/;tx;/cd/p

^{Непорожній рядок виводу є truthy}

Автомати кінцевих держав цього не можуть зробити, скажете ви? А як щодо автоматизованих кінцевих держав з петлями . : P

Бігайте з прапорами rта nпрапорами.

Пояснення

s/.*/c&d/        #Wrap the input in 'c' and 'd' (used as markers)
:x               #Define a label named 'x'
s/ca(.*)bd/c\1d/ #Deletes 'a's preceded by 'c's and equivalently for 'b's and 'd's. This shifts the markers to the center
tx               #If the previous substitution was made, jump to label x
/cd/p            #If the markers are next to one another, print the string

JavaScript, 44 42

^{Закреслений 44 все ще є регулярним 44; (}

f=s=>(z=s.match`^a(.+)b$`)?f(z[1]):s=="ab"

Працює рекурсивно отгонку зовнішніх aі bі рекурсивно з використанням внутрішнього значення , обраним , але .+. Якщо ^a.+b$зліва зліва немає, то кінцевим результатом є те, чи залишилось рядкове точне значення ab.

Тестові приклади:

console.log(["ab","aabb","aaabbb","aaaabbbb","aaaaabbbbb","aaaaaabbbbbb"].every(f) == true)
console.log(["","a","b","aa","ba","bb","aaa","aab","aba","abb","baa","bab","bba","bbb","aaaa","aaab","aaba","abaa","abab","abba","abbb","baaa","baab","baba","babb","bbaa","bbab","bbba","bbbb"].some(f) == false)

ANTLR, 31 байт

grammar A;r:'ab'|'a'r'b'|r'\n';

Використовується та ж концепція, що і відповідь YACC @ dmckee , лише трохи більше гольфу.

Щоб перевірити, виконайте кроки в підручнику " Початок роботи" ANTLR . Потім введіть вищезгаданий код у файл з іменем A.g4та запустіть ці команди:

$ antlr A.g4
$ javac A*.java

Потім тестуйте, подавши вхід на STDIN grun A rтак, щоб:

$ echo "aaabbb" | grun A r

Якщо вхід правильний, нічого не буде виведено; якщо він є недійсним, grunвидасть повідомлення про помилку (або token recognition error, extraneous input, mismatched inputабо no viable alternative).

Приклад використання:

$ echo "aabb" | grun A r
$ echo "abbb" | grun A r
line 1:2 mismatched input 'b' expecting {<EOF>, '
'}

C, 69 байт

69 байт:

#define f(s)strlen(s)==2*strcspn(s,"b")&strrchr(s,97)+1==strchr(s,98)

Для незнайомих:

• strlen визначає довжину струни
• strcspn повертає перший індекс у рядку, де знайдено інший рядок
• strchr повертає вказівник на перше виникнення символу
• strrchr повертає вказівник на останнє виникнення символу

Велика подяка Тіту!

R, 64 61 55 байт, 73 67 байт (надійний) або 46 байт (якщо пусті рядки дозволені)

1. Знову відповідь xnor переробили. Якщо правила мають на увазі, що вхід буде складатися з рядків as і bs, він повинен працювати: повертає NULL, якщо вираз дійсний, кидки та помилки або нічого іншого.

   if((y<-scan(,''))>'')eval(parse(t=chartr('ab','{}',y)))
   

2. Якщо вхід не є надійним і може містити сміття, наприклад aa3bb, слід розглянути таку версію (повинна бути повернена TRUEдля справжніх тестових випадків, а не NULL):

   if(length(y<-scan(,'')))is.null(eval(parse(t=chartr("ab","{}",y))))
   

3. Нарешті, якщо пусті рядки дозволені, ми можемо проігнорувати умову не порожнього введення:

   eval(parse(text=chartr("ab","{}",scan(,''))))
   

   Знову НУЛЬ, якщо успіх, ще щось інакше.

Japt , 11 байт

©¬n eȦUg~Y

Спробуйте в Інтернеті!

Дає trueабо false, за винятком того, що ""дає ""помилкове значення в JS.

Розпаковано та як це працює

U&&Uq n eXYZ{X!=Ug~Y

U&&     The input string is not empty, and...
Uq n    Convert to array of chars and sort
eXYZ{   Does every element satisfy...?
X!=       The sorted char does not equal...
Ug~Y      the char at the same position on the original string reversed

Прийнято з рішення MATL Денніса .

C (Ansi), 65 75 байт

Гольф:

l(b,i,j,k)char*b;{for(i=j=0;(k=b[i++])>0&k<=b[i];)j+=2*(k>97)-1;return !j;}

Пояснення:

Встановлює значення j та прирости j на кожен b, а зменшення j - на будь-що інше. Перевіряється, чи попередній лист менше або рівний наступній букві, тому не дозволяйте абабі працювати

Правки

Додано чеки на випадки абаб.

Пакетна, 133 байт

@if ""=="%1" exit/b1        Fail if the input is empty
@set a=%1                   Grab the input into a variable for processing
@set b=%a:ab=%              Remove all `ab` substrings
@if "%a%"=="%b%" exit/b1    Fail if we didn't remove anything
@if not %a%==a%b%b exit/b1  Fail if we removed more than one `ab`
@if ""=="%b%" exit/b0       Success if there's nothing left to check
@%0 %b%                     Rinse and repeat

Повертає ERRORLEVEL0 на успіх, 1 на провал. Batch не любить робити заміну підрядків на порожніх рядках, тому нам доведеться перевірити це вперед; якщо порожній параметр був законним, рядок 6 не буде необхідним.

PowerShell v2 +, 61 52 байт

param($n)$x=$n.length/2;$n-and$n-match"^a{$x}b{$x}$"

Приймає введення $nяк рядок, створює $xяк half the length. Конструкції -andЛогічне порівняння $nі -matchрегулярний вираз оператора проти регулярного виразу з рівного числа aх і bх років. Виходи Логічне $TRUEабо $FALSE. Це $n-andє для обліку ""= $FALSE.

Чергування, 35 байт

$args-match'^(a)+(?<-1>b)+(?(1)c)$'

Для цього використовується регулярний вираз з відповіді Leaky на основі .NET-балансуючих груп, щойно укладених в -matchоператор PowerShell . Повертає рядок для truthy або порожню рядок для falsey.

Pyth - 13 байт

&zqzS*/lz2"ab

Пояснили:

  qz          #is input equal to
          "ab #the string "ab"
     *        #multiplied by
      /lz2    #length of input / 2
    S         #and sorted?
&z            #(implicitly) print if the above is true and z is not empty

Хаскелл, 39 байт

p x=elem x$scanl(\s _->'a':s++"b")"ab"x

Приклад використання: p "aabb"-> True.

scanl(\s _->'a':s++"b")"ab"xскласти список усіх ["ab", "aabb", "aaabbb", ...]із загальною кількістю (length x)елементів. elemперевіряє, чи xє в цьому списку.

Пітон, 43 40 байт

lambda s:''<s==len(s)/2*"a"+len(s)/2*"b"

переглянуло очевидне рішення завдяки Leaky Nun

інша ідея, 45 байт:

lambda s:s and list(s)==sorted(len(s)/2*"ab")

-4 байти, використовуючи len / 2 (я отримую помилку, коли половина настає останньою)

тепер дає false для порожнього рядка

-3 байти завдяки xnor