在彼得·林茨（Peter Linz ）的一本流行（且必不可少的）计算机科学书籍《形式语言和自动机简介》中，经常提到以下形式语言：

主要是因为无法使用有限状态自动机处理该语言。此表达式的意思是“语言L由'a'的所有字符串组成，后跟'b'，其中'a'和'b'的数量相等且非零”。

挑战

编写一个工作程序/函数，该程序将获取仅包含“ a”和“ b”的字符串作为输入，并返回/输出真值，并说出该字符串是否对形式语言L有效。

• 您的程序不能使用任何外部计算工具，包括网络，外部程序等。Shell是此规则的例外；例如，Bash可以使用命令行实用程序。

• 您的程序必须以“逻辑”方式返回/输出结果，例如：返回10而不是0，“哔”声，输出到stdout等。此处有更多信息。

• 适用标准代码高尔夫规则。

这是一个代码高尔夫球。以字节为单位的最短代码获胜。祝好运！

真实的测试案例

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

如果字符串属于L，则输出一个1 s 的非空数组，否则输出一个空数组或一个0 s 的数组（均为falsy）。

感谢@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))

通过退出代码输出：错误为false，错误为True。

该字符串被评价为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长1个字节；感谢isaacg指出了这一点。

视网膜，12字节

归功于独立找到此解决方案的FryAmTheEggman。

+`a;?b
;
^;$

打印1有效输入，0否则输出。

在线尝试！（第一行启用换行分隔的测试套件。）

说明

平衡组需要昂贵的语法，因此我试图将有效输入减少为简单形式。

阶段1

+`a;?b
;

该+告诉视网膜重复此阶段的循环，直到输出停止变化。它与ab或匹配，a;b并用替换;。让我们考虑几种情况：

• 如果aS和b字符串s中没有在相同的方式，平衡(和)正常需要是，一些a或b将保持在字符串中，因为ba，或b;a不能得到解决，一个a或b自身不能要么。要摆脱所有as和bs，必须有一个对应b于每个s 的权利a。
• 如果a和b都不都是嵌套的（例如，如果我们有类似abab或的嵌套aabaabbb），那么我们将得到多个;（可能还有as和bs），因为第一次迭代将找到多个abs来插入它们，并且进一步的迭代将保留;字符串中的数字。

因此，当且仅当输入为形式时，我们才会在字符串中以单个结尾。anbn;

阶段2：

^;$

检查结果字符串是否仅包含一个分号。（当我说“ check”时，我的意思是“计算给定正则表达式的匹配次数，但是由于锚点，该正则表达式最多可以匹配一次，因此给出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。

Brachylog，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'#~-:@#)

这可以正确地为空字符串提供falsey。错误是错误的。

旧版本：

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

证明与解释

主要动词是包含以下三个动词的叉子：

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

意思是，“（<.）中的较小值是长度（#）和右叉（(-:'ab'#~-:@#)）的结果”。

右叉是4列，包括：

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

让我们k代表我们的输入。然后，这等效于：

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

-:是match运算符，因此-:对monadic fork下的不变性进行前导检验'ab' #~ -:@#。

由于fork的左齿是动词，因此它成为常数函数。因此，fork等效于：

'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后接任何可接受的序列，后接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上递归。仅当两个长度相等时才匹配。

感谢Martin Ender将字节数减半并教了我一些有关正则表达式中递归的知识：D

如果匹配则返回整个字符串，否则返回任何字符串。

在这里尝试！

JavaScript，54 55 44

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

根据字符串的长度构建一个简单的正则表达式并对其进行测试。对于长度为4的字符串（aabb），正则表达式如下所示：^a{2}b{2}$

返回真实或错误的值。

感谢Neil，节省了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.8.2.2 @Ubuntu一起编译

感谢ugoren的提示！

在Ideone上尝试！

视网膜，22字节

另一个用相同语言的简短答案就来了...

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

在线尝试！

这是regex平衡组的展示，Martin Ender对此做了充分解释。

由于我的解释还不能接近它的一半，因此我将仅链接到它，而不是试图进行解释，因为这将不利于他的解释的荣耀。

Befunge-93，67个字节

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

在这里尝试！可能稍后再解释。可能还会尝试多打一点高尔夫球，只是为了踢球。

MATL，9个字节

vHI$e!d1=

在线尝试！

如果输出数组为非空且其所有条目均为非零，则为true。否则是虚假的。这里有一些例子。

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字节

十六进制转储：

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

Ruby，24个字节

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

（这只是xnor以Ruby形式提出的绝妙想法。我的另一个答案是我实际上一个解决方案。）

该程序将输入，转换a并转换b为[]分别和，然后对其求值。

有效输入将形成一个嵌套数组，并且什么也不会发生。不平衡的表达式会使程序崩溃。在Ruby中，空输入的值为nil，由于nil未定义*方法而将崩溃。

Sed，38 + 2 = 40字节

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

^{非空字符串输出是正确的}

有限状态自动机不能做到这一点，你说呢？带有循环的有限状态自动机呢？？：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';

使用与@dmckee的YACC答案相同的概念，但打高尔夫球的次数略多一些。

要进行测试，请遵循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 返回一个指向字符最后一次出现的指针

非常感谢Titus！

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(,''))))
   

   同样，如果成功则为NULL，否则为其他任何值。

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

从Dennis的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并在每个b上递增j，在其他任何值上递减j。检查前面的字母是否小于或等于下一个字母，以防止Abab工作

编辑

添加了对abab病例的检查。

批处理，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

ERRORLEVEL成功返回0，失败返回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的答案中的正则表达式，它基于封装在PowerShell -match运算符中的.NET平衡组。返回真值字符串，或假值字符串为空。

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

Haskell，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在此列表中。

Python，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")

通过使用len / 2 -4个字节（当最后一半出现时我得到一个错误）

现在为空字符串给出false

-3个字节感谢xnor