国际象棋移动的正则表达式帮助（SAN）

Question

我正在写一个程序，应该能够读取和解析国际象棋的动作（SAN）。

下面是一个可能被接受的动作的例子：

e4
Nf3
Nbd2
Nb1c3
R1a3
d8=Q
exd5
Nbxd2
...

我首先编写了NFA，然后将其转换为语法，然后将其转换为正则表达式。

按照我的惯例，情况就是这样

pln + plxln + plnxln + plnln + plln + pxln + lxln=(B+R+Q+N) + lxln + lnxln=(B+R+Q+N) + lnxln + lnln=(B+R+Q+N) + lnln + ln=(B+R+Q+N) + ln + pnxln + pnln

哪里：

p是set{B， R， Q， N， K}的字符（或者认为是（B R Q N K）=[BRQNK]

l是[a-h]间隔中的一个字符（区分大小写）

n是[1-8]间隔中的一个数字

表示联合操作。。。如果我没弄错的话，（BRQN）在regex的编程语言中是[BRQN]。

=只是一个普通字符。。。在国际象棋中，它用于提升（例如e8=Q）

x也是一个普通字符。。。当你在那个位置移动你的棋子时，你正在拿对手的棋子。

（/）：比如数学

我试图解析第一部分pln为：[BRQN][a-h][1-8]在一个在线java正则表达式测试器中，并为像Nf3这样的移动而工作。我不知道如何为复合表达式做联合的事情（如pln plxln）...我还如何标记正则表达式的一部分，以便在检测到它时，我得到所有的信息？我试图阅读关于它的文档，但没有弄清楚。

有什么建议吗？

Answer 1

Re: /^([NBRQK])?([a-h])?([1-8])?(x)?([a-h][1-8])(=[NBRQK])?(\+|#)?$|^O-O(-O)?$/

这既有包容性不足，也有包容性过高。

它排除了可能的合法移动O-O，O-O-O，O-O#和O-O-O#。

它包含许多永远不合法的字符串：e8=K、Kaa4、Nf5=B、Qa1xb7

等等

Answer 2

/^（[NBRQK]）？（[a-h]）？([1-8])?（x） ?？（[a-h][1-8]）（=[NBRQK]）？(\ |#)?$|^O-O（-O）$/

.

.

.

.

这是对2599例进行的单元测试。单元测试见下文

describe('Importer/Game', function() {
    let Importer, Game;
    beforeEach(function() {
        Importer = require(`${moduleDir}/import`).Importer;
        Game = require(`${moduleDir}/import`).Game;
    });
    describe('moveRegex', function() {
        describe('non-castling', function() {
            //  ([NBRQK])?  ([a-h])?   ([1-8])?   (x)?     ([a-h][1-8]) (=[NBRQK])? (+|#)?/
            //  unitType?   startFile? startRank? capture? end          promotion?  checkState?
            for(let unitType of ['', 'N', 'B', 'R', 'Q', 'K']) {
                for(let startFile of ['', 'b']) {
                    for(let startRank of ['', '3']) {
                        for(let capture of ['', 'x']) {
                            for(let promotion of ['', '=Q']) {
                                for(let checkState of ['', '+', '#']) {
                                    //TODO: castling
                                    const dest = 'e4';
                                    const san = unitType + startFile + startRank + capture + dest + promotion + checkState;
                                    testPositive(san);
                                    //TODO: negative substitutions here.
                                    testNagative('Y'      + startFile + startRank + capture + dest + promotion + checkState);
                                    testNagative(unitType + 'i'       + startRank + capture + dest + promotion + checkState);
                                    testNagative(unitType + startFile + '9'       + capture + dest + promotion + checkState);
                                    testNagative(unitType + startFile + startRank + 'X'     + dest + promotion + checkState);
                                    testNagative(unitType + startFile + startRank + capture + 'i9' + promotion + checkState);
                                    // testNagative(unitType + startFile + startRank + capture + ''   + promotion + checkState);
                                    testNagative(unitType + startFile + startRank + capture + dest + '='       + checkState);
                                    testNagative(unitType + startFile + startRank + capture + dest + 'Q'       + checkState);
                                    testNagative(unitType + startFile + startRank + capture + dest + promotion + '++');
                                }
                            }
                        }
                    }
                }
            }
        });
        describe('castling', function() {
            testPositive('O-O');
            testPositive('O-O-O');
            testNagative('OOO');
            testNagative('OO');
            testNagative('O-O-');
            testNagative('O-O-O-O');
            testNagative('O');
        });
        function testPositive(san) {
            it(`should handle this san: ${san}`, function(done) {
                const matches = san.match(Importer.moveRegex);
                assert(matches);
                done();
            });
        }
        function testNagative(san) {
            it(`should not match this: ${san}`, function(done) {
                const matches = san.match(Importer.moveRegex);
                assert(!matches);
                done();
            });
        }
    });
});

Answer 3

表示法中的是regex中的|。所以你可以用正则表达式

[BRQNK][a-h][1-8]|[BRQNK][a-h]x[a-h][1-8]|[BRQNK][a-h][1-8]x[a-h][1-8]|[BRQNK][a-h][1-8][a-h][1-8]|[BRQNK][a-h][a-h][1-8]|[BRQNK]x[a-h][1-8]|[a-h]x[a-h][1-8]=(B+R+Q+N)|[a-h]x[a-h][1-8]|[a-h][1-8]x[a-h][1-8]=(B+R+Q+N)|[a-h][1-8]x[a-h][1-8]|[a-h][1-8][a-h][1-8]=(B+R+Q+N)|[a-h][1-8][a-h][1-8]|[a-h][1-8]=(B+R+Q+N)|[a-h][1-8]|[BRQNK][1-8]x[a-h][1-8]|[BRQNK][1-8][a-h][1-8]

这显然有点丑陋。我能想到两种可能的方法让它变得更好：

• 使用COMMENTS标志，可以添加空白。
• 以更好的方式将这些可能性结合在一起。例如，[BRQNK][a-h]x[a-h][1-8]|[BRQNK][a-h][1-8]x[a-h][1-8]可以重写为[BRQNK][a-h][1-8]？x[a-h][1-8].

我还知道java中没有的另一个改进。（可能不是很多语言，但可以用Perl实现。）子表达式（？1）（同样地（？2），等等）有点像\1，只是它没有匹配匹配第一个捕获组的确切字符串，而是匹配可能匹配该捕获组的任何字符串。换句话说，这相当于再次写出捕获组。因此，您可以（在Perl中）将第一个[BRQNK]替换为（[BRQNK]），然后将所有后续出现的内容替换为（？1）。