Trong cuốn sách khoa học máy tính phổ biến (và thiết yếu), Giới thiệu về Ngôn ngữ chính thức và Automata của Peter Linz, ngôn ngữ chính thức sau đây thường được nêu:

chủ yếu là vì ngôn ngữ này không thể được xử lý với automata trạng thái hữu hạn. Biểu thức này có nghĩa là "Ngôn ngữ L bao gồm tất cả các chuỗi 'a theo sau là' b ', trong đó số' a 'và' b 'bằng nhau và khác không".

Thử thách

Viết chương trình / hàm làm việc có một chuỗi, chỉ chứa "a" s và "b" , làm đầu vào và trả về / xuất giá trị thật , cho biết nếu chuỗi này hợp lệ là ngôn ngữ chính thức L.

• Chương trình của bạn không thể sử dụng bất kỳ công cụ tính toán bên ngoài nào, bao gồm mạng, chương trình bên ngoài, v.v ... Shell là một ngoại lệ đối với quy tắc này; Bash, ví dụ, có thể sử dụng các tiện ích dòng lệnh.

• Chương trình của bạn phải trả về / xuất kết quả theo cách "hợp lý", ví dụ: trả về 10 thay vì 0, âm thanh "bíp", xuất ra thiết bị xuất chuẩn, v.v. Thông tin thêm ở đây.

• Quy tắc golf tiêu chuẩn áp dụng.

Đây là một mã golf . Mã ngắn nhất trong byte thắng. Chúc may mắn!

Trường hợp thử nghiệm thật

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

Trường hợp thử nghiệm giả

""
"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 byte

tSP-

In một mảng không trống 1 s nếu chuỗi thuộc về L và một mảng trống hoặc một mảng có 0 s (cả hai đều sai).

Cảm ơn @LuisMendo vì đã chơi golf 1 byte!

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

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

Đầu ra thông qua mã thoát : Lỗi sai, không có lỗi cho True.

Chuỗi được đánh giá là mã Python, thay thế parens (cho avà )cho b. Chỉ các biểu thức của biểu mẫu a^n b^ntrở thành biểu thức được định dạng tốt của dấu ngoặc đơn ((())), đánh giá cho bộ dữ liệu ().

Bất kỳ dấu ngoặc không khớp nào cũng có lỗi, cũng như nhiều nhóm sẽ thích (()()), vì không có dấu phân cách. Chuỗi rỗng cũng thất bại (nó sẽ thành công trên exec).

Việc chuyển đổi ( -> a, ) -> bđược thực hiện bằng cách sử dụng str.translate, thay thế các ký tự như được chỉ định bởi một chuỗi đóng vai trò là bảng chuyển đổi. Với chuỗi 100 độ dài ") (" * 50, các bảng ánh xạ 100 giá trị ASCII đầu tiên là

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

mà mất ( -> a, ) -> b. Trong Python 2, các chuyển đổi cho tất cả 256 giá trị ASCII phải được cung cấp, yêu cầu "ab"*128, dài hơn một byte; cảm ơn isaacg đã chỉ ra điều này

Võng mạc , 12 byte

Tín dụng cho FryAmTheEggman, người đã tìm thấy giải pháp này một cách độc lập.

+`a;?b
;
^;$

In 1cho đầu vào hợp lệ và 0cách khác.

Hãy thử trực tuyến! (Dòng đầu tiên cho phép bộ kiểm tra được phân tách bằng nguồn cấp.)

Giải trình

Các nhóm cân bằng đòi hỏi cú pháp đắt tiền, vì vậy thay vào đó tôi đang cố gắng giảm đầu vào hợp lệ thành một hình thức đơn giản.

Giai đoạn 1

+`a;?b
;

Việc báo +cho Retina lặp lại giai đoạn này trong một vòng lặp cho đến khi đầu ra ngừng thay đổi. Nó phù hợp với hoặc abhoặc a;bthay thế nó bằng ;. Hãy xem xét một vài trường hợp:

• Nếu as và bs trong chuỗi không cân bằng theo cùng một cách (và )thông thường cần phải có, một số ahoặc bsẽ vẫn ở trong chuỗi, vì ba, hoặc b;akhông thể được giải quyết và một ahoặc bkhông thể tự mình hoặc. Để thoát khỏi tất cả các as và bs phải có một tương ứng bvới bên phải của mỗi a.
• Nếu avà bđang không phải tất cả lồng nhau (ví dụ như nếu chúng ta có một cái gì đó giống như ababhoặc aabaabbb) sau đó chúng tôi sẽ kết thúc với nhiều ;(và có thể một số as và bs) bởi vì phiên đầu tiên sẽ tìm thấy nhiều abs để chèn chúng và lặp đi lặp lại sẽ tiếp tục duy trì số lượng ;trong chuỗi.

Do đó, nếu và chỉ khi đầu vào có dạng , chúng ta sẽ kết thúc bằng một chuỗi trong chuỗi.anbn;

Giai đoạn 2:

^;$

Kiểm tra xem chuỗi kết quả có chứa gì ngoài một dấu chấm phẩy không. (Khi tôi nói "kiểm tra" ý tôi thực sự là ", hãy đếm số lượng trận đấu của regex đã cho, nhưng vì regex đó có thể khớp nhiều nhất một lần do các neo, điều này mang lại 0hoặc 1.)

Haskell, 31 byte

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

Việc hiểu danh sách [c|c<-"ab",'a'<-s]tạo ra một chuỗi một 'a'cho mỗi 'a'trong s, theo sau là một 'b'cho mỗi 'a'trong s. Nó tránh đếm bằng cách khớp trên hằng số và tạo đầu ra cho mỗi trận đấu.

Chuỗi này được kiểm tra bằng với chuỗi gốc và chuỗi gốc được kiểm tra là không trống.

Vết bẩn , 12 byte

A=\aA?\b
e`A

Hãy thử trực tuyến!

Giải trình

Dòng đầu tiên định nghĩa một nonterminal A, khớp với một chữ cái a, có thể là nonterminal A, và sau đó là một chữ cái b. Dòng thứ hai khớp với toàn bộ đầu vào ( e) so với nonterminal A.

Phiên bản không biên dịch 8 byte

e`\a_?\b

Sau khi viết phiên bản đầu tiên của câu trả lời này, tôi đã cập nhật Grime để xem _là tên của biểu thức cấp cao nhất. Giải pháp này tương đương với ở trên, nhưng tránh lặp lại nhãn A.

Brachylog , 23 19 byte

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

Hãy thử trực tuyến!

Giải trình

@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 byte

Mã số:

.M{J¹ÔQ0r

Giải trình:

.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).

Hai byte cuối cùng có thể bị loại bỏ nếu đầu vào được đảm bảo không trống.

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Thạch , 6 byte

Ṣ=Ṛ¬Pȧ

Tự in chuỗi nếu nó thuộc L hoặc trống và 0 khác.

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

Ṣ=Ṛ¬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 == "".

Phiên bản thay thế, 4 byte (không cạnh tranh)

ṢnṚȦ

In 1 hoặc 0 . Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

Ṣ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 byte

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

Điều này hoạt động chính xác để đưa falsey cho chuỗi trống. Lỗi là chim ưng.

Phiên bản cũ:

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

Bằng chứng và giải thích

Động từ chính là một ngã ba bao gồm ba động từ sau:

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

Điều này có nghĩa là, "Nhỏ hơn ( <.) độ dài ( #) và kết quả của tine phải ( (-:'ab'#~-:@#))".

Tine bên phải là 4 tàu , bao gồm:

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

Hãy kđại diện cho đầu vào của chúng tôi. Sau đó, điều này tương đương với:

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

-:là toán tử khớp, do đó, các -:thử nghiệm hàng đầu cho bất biến dưới ngã ba đơn âm 'ab' #~ -:@#.

Vì tine trái của ngã ba là một động từ, nó trở thành một hàm không đổi. Vì vậy, ngã ba tương đương với:

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

Tine phải của nửa ngã ba ( -:) chiều dài ( #) của k. Quan sát #:

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

Bây giờ, đây kchỉ là trên đầu vào hợp lệ, vì vậy chúng tôi được thực hiện ở đây. #lỗi cho chuỗi có độ dài lẻ, không bao giờ thỏa mãn ngôn ngữ, do đó chúng tôi cũng đã thực hiện.

Kết hợp với độ dài nhỏ hơn và chuỗi này, chuỗi rỗng, không phải là một phần của ngôn ngữ của chúng tôi, mang lại độ dài của nó 0và chúng tôi đã hoàn thành tất cả.

Bison / YACC 60 (hoặc 29) byte

(Chà, việc biên dịch cho chương trình YACC là một vài bước nên có thể muốn bao gồm một số cho điều đó. Xem bên dưới để biết chi tiết.)

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

Hàm này khá rõ ràng nếu bạn biết diễn giải nó theo ngữ pháp chính thức. Trình phân tích cú pháp chấp nhận một abhoặc atheo sau bởi bất kỳ chuỗi nào được chấp nhận theo sau bởi mộtb .

Việc triển khai này dựa trên một trình biên dịch chấp nhận ngữ nghĩa K & R để mất một vài ký tự.

Đó là nhiều hơn tôi muốn với nhu cầu xác định yylexvà gọi getchar.

Biên dịch với

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

(hầu hết các tùy chọn cho gcc là dành riêng cho hệ thống của tôi và không nên tính theo số byte; bạn có thể muốn tính -std=c89thêm 8 vào giá trị được liệt kê).

Chạy với

$ echo "aabb" | ./equal

hoặc tương đương.

Giá trị thật được trả về HĐH và lỗi cũng báo cáo syntax errorvới dòng lệnh. Nếu tôi chỉ có thể đếm phần mã xác định hàm phân tích cú pháp (đó là bỏ qua phần thứ hai %%và tất cả các phần tiếp theo), tôi nhận được số lượng 29 byte.

Perl 5.10, 35 17 byte (có cờ -n )

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

Đảm bảo rằng chuỗi bắt đầu bằng as và sau đó đệ quyb s. Nó chỉ phù hợp nếu cả hai chiều dài bằng nhau.

Cảm ơn Martin Ender giảm một nửa số byte và dạy tôi một chút về đệ quy trong regexes: D

Nó trả về toàn bộ chuỗi nếu nó khớp, và không có gì nếu không.

Hãy thử nó ở đây!

JavaScript, 54 55 44

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

Xây dựng một regex đơn giản dựa trên độ dài của chuỗi và kiểm tra nó. Đối với một chuỗi dài 4 ( aabb) regex trông giống như:^a{2}b{2}$

Trả về một giá trị trung thực hoặc falsey.

11 byte được lưu nhờ Neil.

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 byte

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

Giải pháp dài 57 byte cũ:

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

Được biên dịch với gcc v. 4.8.2 @Ubfox

Cảm ơn ugoren cho lời khuyên!

Hãy thử nó trên Ideone!

Võng mạc , 22 byte

Một câu trả lời ngắn hơn trong cùng một ngôn ngữ vừa xuất hiện ...

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

Hãy thử trực tuyến!

Đây là một chương trình giới thiệu về các nhóm cân bằng trong regex, được giải thích đầy đủ bởi Martin Ender .

Vì lời giải thích của tôi sẽ không đến gần một nửa, tôi sẽ chỉ liên kết với nó và không cố gắng giải thích, vì điều đó sẽ gây bất lợi cho vinh quang của lời giải thích của anh ấy.

Befunge-93, 67 byte

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

Hãy thử nó ở đây! Có thể giải thích làm thế nào nó hoạt động sau. Cũng có thể cố gắng đánh golf nó một chút nữa, chỉ để đá.

MATL , 9 byte

vHI$e!d1=

Hãy thử trực tuyến!

Mảng đầu ra là trung thực nếu nó không trống và tất cả các mục của nó là khác không. Nếu không thì đó là giả. Dưới đây là một số ví dụ .

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

mã máy x86, 29 27 byte

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

Mã hội:

    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;

Lặp lại các abyte ở đầu, sau đó qua các byte 'b' sau đây. Vòng lặp thứ nhất tăng bộ đếm và vòng lặp thứ hai giảm nó. Sau đó, thực hiện HOẶC một chút giữa các điều kiện sau:

1. Nếu bộ đếm không phải là 0 ở cuối, chuỗi không khớp
2. Nếu byte theo sau chuỗi bs không bằng 0, chuỗi cũng không khớp

Sau đó, nó phải "đảo ngược" giá trị thật trong eax- đặt nó thành 0 nếu không phải là 0 và ngược lại. Hóa ra mã ngắn nhất để làm điều đó là mã 5 byte sau đây, mà tôi đã đánh cắp từ đầu ra của trình biên dịch C ++ của tôi cho 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

Ruby, 24 byte

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

(Đây chỉ là ý tưởng tuyệt vời của xnor dưới dạng Ruby. Câu trả lời khác của tôi là một giải pháp tôi thực sự tự nghĩ ra.)

Chương trình diễn đầu vào, biến đổi avà bđể [và ]tương ứng, và đánh giá nó.

Đầu vào hợp lệ sẽ tạo thành một mảng lồng nhau, và không có gì xảy ra. Một biểu thức không cân bằng sẽ làm cho chương trình sụp đổ. Trong Ruby, đầu vào trống được đánh giá là nil, nó sẽ sụp đổ vì nilchưa xác định *phương thức.

Sed, 38 + 2 = 40 byte

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

^{Một đầu ra chuỗi không trống là sự thật}

Máy chủ trạng thái hữu hạn không thể làm điều này, bạn nói gì? Điều gì về automata trạng thái hữu hạn với các vòng lặp . : P

Chạy với r và ncờ.

Giải trình

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

^{Vượt qua 44 vẫn là 44 thường xuyên (}

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

Hoạt động bằng cách đệ quy tước bên ngoài avà bvà đệ quy sử dụng giá trị bên trong chọn nhưng .+. Khi không có kết quả khớp ^a.+b$bên trái, thì kết quả cuối cùng là liệu chuỗi còn lại có phải là giá trị chính xác hay không ab.

Các trường hợp thử nghiệm:

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 byte

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

Sử dụng khái niệm tương tự như câu trả lời YACC của @ dmckee , chỉ cần chơi gôn hơn một chút.

Để kiểm tra, hãy làm theo các bước trong hướng dẫn Bắt đầu của ANTLR . Sau đó, đặt đoạn mã trên vào một tệp có tên A.g4và chạy các lệnh sau:

$ antlr A.g4
$ javac A*.java

Sau đó kiểm tra bằng cách cho đầu vào trên STDIN grun A rnhư vậy:

$ echo "aaabbb" | grun A r

Nếu đầu vào hợp lệ, sẽ không có gì là đầu ra; nếu nó là không hợp lệ, grunsẽ đưa ra một lỗi (hoặc token recognition error, extraneous input, mismatched input, hoặc no viable alternative).

Ví dụ sử dụng:

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

C, 69 byte

69 byte:

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

Đối với những người không quen thuộc:

• strlen xác định độ dài của chuỗi
• strcspn trả về chỉ mục đầu tiên trong chuỗi nơi tìm thấy chuỗi khác
• strchr trả về một con trỏ đến lần xuất hiện đầu tiên của một ký tự
• strrchr trả về một con trỏ đến lần xuất hiện cuối cùng của một ký tự

Một lời cảm ơn lớn đến Tít!

R, 64 61 55 byte, 73 67 byte (mạnh mẽ) hoặc 46 byte (nếu chuỗi trống được cho phép)

1. Một lần nữa, câu trả lời của xnor được làm lại. Nếu nó được ngụ ý bởi các quy tắc rằng đầu vào sẽ bao gồm một chuỗi as và bs, thì nó sẽ hoạt động: trả về NULL nếu biểu thức hợp lệ, ném và lỗi hoặc không có gì khác.

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

2. Nếu đầu vào không mạnh mẽ và có thể chứa một số rác, ví dụ: aa3bbthì nên xem xét phiên bản sau (phải trả lại TRUEcho các trường hợp thử nghiệm thực sự, không phải NULL):

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

3. Cuối cùng, nếu chuỗi trống được cho phép, chúng ta có thể bỏ qua điều kiện cho đầu vào không trống:

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

   Một lần nữa, NULL nếu thành công, bất cứ điều gì khác.

Japt , 11 byte

©¬n eȦUg~Y

Hãy thử trực tuyến!

Cung cấp cho một trong hai truehoặc false, ngoại trừ việc ""cung cấp cho ""đó là falsy trong JS.

Giải nén & Cách thức hoạt động

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

Thông qua giải pháp MATL của Dennis .

C (Ansi), 65 75 byte

Chơi gôn

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;}

Giải trình:

Đặt giá trị j và tăng j trên mỗi b và giảm j trên bất kỳ thứ gì khác. Đã kiểm tra nếu chữ cái trước nhỏ hơn hoặc bằng chữ cái tiếp theo để ngăn abab hoạt động

Chỉnh sửa

Đã thêm kiểm tra cho các trường hợp abab.

Mẻ, 133 byte

@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

Trả về ERRORLEVEL0 khi thành công, 1 khi thất bại. Batch không thích thay thế chuỗi con trên các chuỗi trống, vì vậy chúng tôi phải kiểm tra trước; nếu một tham số trống là hợp pháp, dòng 6 sẽ không cần thiết.

PowerShell v2 +, 61 52 byte

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

Lấy đầu vào $ndưới dạng một chuỗi, tạo $xnhư half the length. Xây dựng một -andso sánh Boolean giữa $nvà một -matchtoán tử regex so với biểu thức chính của một số lượng bằng nhau của a's và b'. Đầu ra Boolean$TRUE hoặc $FALSE. Có $n-andtài khoản cho ""= $FALSE.

Thay thế, 35 byte

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

Điều này sử dụng regex từ câu trả lời của Leaky , dựa trên các nhóm cân bằng .NET, chỉ được gói gọn trong -matchtoán tử PowerShell . Trả về chuỗi cho sự thật, hoặc chuỗi trống cho falsey.

Pyth - 13 byte

&zqzS*/lz2"ab

Giải thích:

  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

Haskell, 39 byte

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

Ví dụ sử dụng: p "aabb"-> True.

scanl(\s _->'a':s++"b")"ab"xxây dựng một danh sách tất cả ["ab", "aabb", "aaabbb", ...]với tổng số các (length x)yếu tố.elemkiểm tra nếu xcó trong danh sách này.

Python, 43 40 byte

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

bao gồm các giải pháp rõ ràng nhờ Leaky Nun

ý tưởng khác, 45 byte:

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

-4 byte bằng cách sử dụng len / 2 (tôi gặp lỗi khi một nửa đến sau)

bây giờ cung cấp sai cho chuỗi trống

-3 byte nhờ xnor