背景

在“宝石迷阵”和类似的游戏中，玩家必须在8x8的宝石网格中交换任意两个相邻的宝石（没有对角线），以便连续匹配三个相同颜色的宝石。宝石可以水平或垂直匹配。游戏的进行一直持续到没有动作可导致连续三局为止，此时游戏结束了。

任务

目的是编写一个确定“宝石迷阵”游戏是否还没有结束的程序。换句话说，它必须检查是否有可能连续移动至少三个。连续可以有三个以上的宝石，这仍然是有效的举动。

输入值

您的程序必须通过标准输入接受Bejeweled网格的8x8表示形式。七种宝石颜色中的每一种将由1到7的数字表示。每行将包含一行，并且将输入8行，每行包括8位数字。请参阅示例。您可以假设输入将始终遵循此格式，并且永远不会连续包含三个。

输出量

然后，程序必须输出（至标准输出），yes或者no取决于是否存在至少一个有效动作，该动作将导致连续出现三个或更多宝石。您的程序不得输出yes或的单个实例以外的任何内容no。

规则

您的程序不得使用任何外部文件或资源，命令行参数或要求使用特定的文件名。源代码中字节数最少的程序将获胜。

例子

输入：

12314131
13224145
54762673
61716653
61341144
23453774
27645426
75575656

输出： yes

输入：

35261546
76421754
15743271
62135642
35617653
64565476
54427254
15635465

输出： no

有关其他测试案例，请参见下面的MT0答案。

原来的解决方案：JavaScript的- 261 255 228 227个 179 153字符

/(\d)(\1(\d|.{6}|.{9})|(\d|.{6}|.{9})\1|.{7}\1(.|.{9})|(.|.{9})\1.{7}|(.{7,9}|.{17})\1.{8}|.{8}\1(.{7,9}|.{17}))\1/.test(s.replace(/\n/g,'A'))?'yes':'no'

假设要测试的字符串在变量中s（使其成为一个函数，f然后将其添加f=s=>到代码的开头，否则，从提示符处获取输入，然后替换s为prompt()）。

输出到控制台。

3 ^RD解决方案：的JavaScript（ECMAScript的6） - 178点的字符

p=x=>parseInt(x,36);for(t="2313ab1b8a2a78188h9haj9j8iaiir9r",i=v=0;s[i];i++)for(j=0;t[j];v|=s[i]==s[i+a]&s[i]==s[i+b]&i%9<8&(b>3|(i+b-a)%9<8))a=p(t[j++]),b=p(t[j++]);v?'yes':'no'

我采用了下面的^第二种解决方案（使用正则表达式来检查某些配置中的字符），并对其进行了重做以仅检查字符串中是否具有相同配置中的相同字符，而不使用正则表达式。

Base-36字符串"2313ab1b8a2a78188h9haj9j8iaiir9r"提供了要检查的偏移量对-即，该对23导致检查^第 i ^个字符是否与第（i + 2）^个字符以及第（i + 3）^个字符相同（与正则表达式等效）(.).\1\1-进行一些附加检查，以确保不相同的字符不是换行符）。

2 ^第二解决方案：的JavaScript（ECMAScript的6） - 204的字符

p=x=>parseInt(x,18);g=a=>a?a>1?"(.|\\n){"+a+"}":".":"";f=(x,a,b)=>RegExp("(.)"+g(a)+"\\1"+g(b)+"\\1").test(x);for(t="10907160789879h8",i=v=0;t[i];v|=f(s,x,y)||f(s,y,x))x=p(t[i++]),y=p(t[i++]);v?'yes':'no'

使用从Base-18字符串中10907160789879h8获取的值对构建多个正则表达式（请参见下文以获取更多详细信息），并接受OR所有测试的。为了进一步简化，您可以注意到正则表达式成对出现，其中一个是另一个的“反向”（忽略水平和垂直3合一行的正则表达式，因为OP表示它们永远不会出现-如果您想将这些测试重新添加0088到Base-18字符串的后面）。

说明

从16个正则表达式开始，涵盖所有有效动作的可能配置：

REs=[
    /(\d)\1\1/,                 // 3-in-a-row horizontally
    /(\d).\1\1/,                // 3-in-a-row horizontally after left-most shifts right
    /(\d)\1.\1/,                // 3-in-a-row horizontally after right-most shifts left
    /(\d)(?:.|\n){9}\1\1/,  // 3-in-a-row horizontally after left-most shifts down
    /(\d)(?:.|\n){7}\1.\1/, // 3-in-a-row horizontally after middle shifts down
    /(\d)(?:.|\n){6}\1\1/,  // 3-in-a-row horizontally after right-most shifts down
    /(\d)\1(?:.|\n){6}\1/,  // 3-in-a-row horizontally after left-most shifts up
    /(\d).\1(?:.|\n){7}\1/, // 3-in-a-row horizontally after middle shifts up
    /(\d)\1(?:.|\n){9}\1/,  // 3-in-a-row horizontally after right-most shifts up
    /(\d)(?:.|\n){7,9}\1(?:.|\n){8}\1/, // 3-in-a-row vertically (with optional top shifting left or right)
    /(\d)(?:.|\n){7}\1(?:.|\n){9}\1/,   // 3-in-a-row vertically after middle shifts right
    /(\d)(?:.|\n){9}\1(?:.|\n){7}\1/,   // 3-in-a-row vertically after middle shifts left
    /(\d)(?:.|\n){8}\1(?:.|\n){7}\1/,   // 3-in-a-row vertically after bottom shifts right
    /(\d)(?:.|\n){8}\1(?:.|\n){9}\1/,   // 3-in-a-row vertically after bottom shifts left
    /(\d)(?:.|\n){17}\1(?:.|\n){8}\1/,  // 3-in-a-row vertically after top shifts down
    /(\d)(?:.|\n){8}\1(?:.|\n){17}\1/,  // 3-in-a-row vertically after bottom shifts up
];

（注：regexs 3-在一个排水平（0 ^次）和垂直方向的9的（一部分^个）是不相关的OP指出输入匹配这些决不会存在。）

对这些输入进行测试将确定是否可以找到该配置的有效移动。

但是，可以将正则表达式组合起来以得到以下6个：

/(\d)(?:.|(?:.|\n){9}|(?:.|\n){6})?\1\1/            // Tests 0,1,3,5
/(\d)\1(?:.|(?:.|\n){9}|(?:.|\n){6})?\1/            // Tests 0,2,6,8
/(\d)(?:.|\n){7}\1(?:.|(?:.|\n){9})\1/              // Tests 4,10
/(\d)(?:.|(?:.|\n){9})\1(?:.|\n){7}\1/              // Tests 7,11
/(\d)(?:(?:.|\n){7,9}|(?:.|\n){17})\1(?:.|\n){8}\1/ // Tests 9,14
/(\d)(?:.|\n){8}\1(?:(?:.|\n){7,9}|(?:.|\n){17})\1/ // Tests 9a,12,13,15

然后可以将它们组合成单个正则表达式：

/(\d)(?:.|(?:.|\n){9}|(?:.|\n){6})?\1\1|(\d)\2(?:.|(?:.|\n){9}|(?:.|\n){6})?\2|(\d)(?:.|\n){7}\3(?:.|(?:.|\n){9})\3|(\d)(?:.|(?:.|\n){9})\4(?:.|\n){7}\4|(\d)(?:(?:.|\n){7,9}|(?:.|\n){17})\5(?:.|\n){8}\5|(\d)(?:.|\n){8}\6(?:(?:.|\n){7,9}|(?:.|\n){17})\6/

只需对输入进行测试。

测试用例

其他人可能会觉得有用的一些测试用例（不符合仅使用数字1-7的输入格式，但是这种格式很容易纠正，并且只有8x4网格-因为这是测试所有有效输入的最低要求）。

从输入字符串到它上面的16个正则表达式匹配的映射格式。

Tests={
    "12345678\n34567812\n56781234\n78123456": -1, // No Match
    "12345678\n34969912\n56781234\n78123456": 1,    // 3-in-a-row horizontally after left-most shifts right 
    "12345678\n34567812\n59989234\n78123456": 2,    // 3-in-a-row horizontally after right-most shifts left
    "12345978\n34567899\n56781234\n78123456": 3,    // 3-in-a-row horizontally after left-most shifts down
    "12345978\n34569892\n56781234\n78123456": 4,    // 3-in-a-row horizontally after middle shifts down
    "12345678\n34967812\n99781234\n78123456": 5,    // 3-in-a-row horizontally after right-most shifts down
    "12399678\n34967812\n56781234\n78123456": 6,    // 3-in-a-row horizontally after left-most shifts up
    "12345678\n34597912\n56789234\n78123456": 7,    // 3-in-a-row horizontally after middle shifts up
    "12345998\n34567819\n56781234\n78123456": 8,    // 3-in-a-row horizontally after right-most shifts up
    "12945678\n34597812\n56791234\n78123456": 9,    // 3-in-a-row vertically after top shifts right
    "12349678\n34597812\n56791234\n78123456": 9,    // 3-in-a-row vertically after top shifts left
    "12345978\n34569812\n56781934\n78123456": 10,   // 3-in-a-row vertically after middle shifts right
    "92345678\n39567812\n96781234\n78123456": 11,   // 3-in-a-row vertically after middle shifts left
    "12945678\n34967812\n59781234\n78123456": 12,   // 3-in-a-row vertically after bottom shifts right
    "12349678\n34569812\n56781934\n78123456": 13,   // 3-in-a-row vertically after bottom shifts left
    "12395678\n34567812\n56791234\n78193456": 14,   // 3-in-a-row vertically after top shifts down
    "12345698\n34567892\n56781234\n78123496": 15,   // 3-in-a-row vertically after bottom shifts up
    "12345678\n34567899\n96781234\n78123456": -1,   // No match - Matches (.)\1.\1 but not 3 in a row
    "12345679\n99567812\n56781234\n78123456": -1,   // No match - Matches (.).\1\1 but not 3 in a row
};

编辑1

将\ds 替换为.-保存6个字符。

编辑2

替换(?:.|\n)与[\s\S]除去额外的非捕获组并更新反向引用（如通过建议M-布特尼）和在有/无输出加入。

编辑3

• 添加了ECMAScript 6解决方案，以从Base-18字符串构建单个正则表达式。
• 删除了水平3 合一测试（如m-buettner所建议）。

编辑4

添加了另一个（更短的）解决方案和两个不匹配的测试用例。

编辑5

• 通过用非数字字符替换换行符来缩短原始解决方案（如VadimR所建议）。

编辑6

• 通过组合正则表达式的位来缩短原始解决方案（如VadimR所建议）。

Python 383

只需一行Python代码！

a=[list(l)for l in raw_input().split('\n')];z=any;e=enumerate;c=lambda b:z(all(p==b[y+v][x+u]for(u,v)in o)for y,r in e(b[:-2])for x,p in e(r[:-2])for o in [[(0,1),(0,2)],[(1,0),(2,0)]]);print z(c([[q if(i,j)==(m,n)else a[m][n]if(i,j)==(y+1,x+1)else p for j,p in e(r)]for i,r in e(a)])for y,t in e(a[1:-1])for x,q in e(t[1:-1])for n,m in((x+u,y+v)for u,v in[(1,0),(1,2),(0,1),(2,1)]))

*使用分号，但这在python中仍然很简单（python一线很有趣！）

Node.js-天真的解决方案-905字节

好吧，还没有答案，所以我将在Node.js中发布一个非常幼稚的解决方案

它会进行所有可能的移动，然后测试结果板，看是否连续有3个。

打高尔夫球（使用Google Closure编译器）（其中有些骇人的东西，如！0和！1；我什至不知道XOR交换对它有什么影响）

Array.prototype.a=function(){for(var f=[],d=0;d<this.length;d++)f[d]=this[d].a?this[d].a():this[d];return f};for(var a=[],b=0;8>b;b++)a[b]=[];for(b=2;b<process.argv.length;b++)for(var c=process.argv[b].split(""),e=0;e<c.length;e++)a[b-2][e]=parseInt(c[e],10);function h(){for(var d=l,f=0;f<d.length-2;f++)for(var g=0;g<d[f].length-2;g++){var k=d[f][g];if(k==d[f+1][g]&&k==d[f+2][g]||k==d[f][g+1]&&k==d[f][g+2])return!0}return!1}function m(){console.log("yes");process.exit()}for(b=0;b<a.length;b++)for(e=0;e<a[b].length;e++){var l=a.a();0!=b&&(l[b-1][e]^=l[b][e],l[b][e]^=l[b-1][e],l[b-1][e]^=l[b][e],h()&&m(),l=a.a());b!=a.length-1&&(l[b+1][e]^=l[b][e],l[b][e]^=l[b+1][e],l[b+1][e]^=l[b][e],h()&&m(),l=a.a());0!=e&&(l[b][e-1]^=l[b][e],l[b][e]^=l[b][e-1],l[b][e-1]^=l[b][e],h()&&m(),l=a.a());e!=a[b].length-1&&(l[b][e+1]^=l[b][e],l[b][e]^=l[b][e+1],l[b][e+1]^=l[b][e],h()&&m(),l=a.a())}console.log("no");

请注意，这是我在手机上编写的所有内容，没有时间对其进行任何测试。如果您发现任何错误，请发表评论，我稍后再检查。

预高尔夫的人类可读版本

// set it up
Array.prototype.clone = function() {
    var arr = [];
    for( var i = 0; i < this.length; i++ ) {
        if( this[i].clone ) {
             arr[i] = this[i].clone();
        } else {
             arr[i] = this[i];
        }
    }
};
var board=[];
for(var i=0;i<8;i++)board[i]=[];
for(var i=2;i<process.argv.length;i++){
    var row=process.argv[i].split("");
    for(var j=0;j<row.length;j++)board[i-2][j]=parseInt(row[j], 10);
}
// function to test
function testBoard(arr){
    for(var i=0;i<arr.length-2;i++){
        for(var j=0;j<arr[i].length-2;j++){
            var val=arr[i][j];
            if(val==arr[i+1][j] && val==arr[i+2][j])return true;
            if(val==arr[i][j+1] && val==arr[i][j+2])return true;
        }
    }
    return false;
}
// functions to exit
function yay(){console.log("yes");process.exit();}
function nay(){console.log("no");}
// super slow naive solution time
for(var i=0;i<board.length;i++){
    for(var j=0;j<board[i].length;j++){
        var newboard=board.clone();
        if(i!=0){
            newboard[i-1][j]=newboard[i-1][j]^newboard[i][j];// whoa, it's a
            newboard[i][j]=newboard[i-1][j]^newboard[i][j];  // cool algorithm
            newboard[i-1][j]=newboard[i-1][j]^newboard[i][j];// at least this 
                                                             // isn't all naive
            if(testBoard(newboard))yay();
            newboard=board.clone();
        }
        if(i!=board.length-1){
            newboard[i+1][j]=newboard[i+1][j]^newboard[i][j];
            newboard[i][j]=newboard[i+1][j]^newboard[i][j];
            newboard[i+1][j]=newboard[i+1][j]^newboard[i][j];
            if(testBoard(newboard))yay();
            newboard=board.clone();
        }
        if(j!=0){
            newboard[i][j-1]=newboard[i][j-1]^newboard[i][j];
            newboard[i][j]=newboard[i][j-1]^newboard[i][j];
            newboard[i][j-1]=newboard[i][j-1]^newboard[i][j];
            if(testBoard(newboard))yay();
            newboard=board.clone();
        }
        if(j!=board[i].length-1){
            newboard[i][j+1]=newboard[i][j+1]^newboard[i][j];
            newboard[i][j]=newboard[i][j+1]^newboard[i][j];
            newboard[i][j+1]=newboard[i][j+1]^newboard[i][j];
            if(testBoard(newboard))yay();
            newboard=board.clone();
        }
    }
}
nay();

Perl，114 96 95 93 92 87 86 85字节

包括+ -a0p

使用STDIN上的输入运行：

bejeweled.pl
12314131
13224145
54762673
61716653
61341144
23453774
27645426
75575656
^D

bejeweled.pl：

#!/usr/bin/perl -a0p
$i/s%.%chop$F[$i++&7]%eg>3|/(.)((.|\H{6}|\H{9})\1|\H{7}\1.)\1/||redo;$_=$1?yes:n.o

这结合了旋转的单方向水平正则表达式解决方案

说明：

在此解决方案中，我将反复旋转并进行以下4个测试：

/(.).\1\1/,      // 3-in-a-row horizontally after left-most shifts right
/(.)\C{9}\1\1/,  // 3-in-a-row horizontally after left-most shifts down
/(.)\C{7}\1.\1/, // 3-in-a-row horizontally after middle shifts down
/(.)\C{6}\1\1/,  // 3-in-a-row horizontally after right-most shifts down

\C“任何字符” 在哪里（不同于.包括换行符的字符）。除非\C已弃用并导致警告，所以我改用\H（非水平空间），它足以捕获所有数字和换行符。

旋转4次后，将完成所有需要的16个测试

-p                            Read lines from STDIN, print $_ at the end
-0                            No line ending => slurp ALL of STDIN
-a                            Split $_ into @F. Since there are no spaces
                              on the rows this means each element of @F is
                              1 row

    s%.%chop$F[$i++&7]%eg     Replace each row by the removed last column
                              This is therefore a left rotation. Very short
                              but at the cost of using @F. To make sure that
                              @F gets refilled from $_ each time I won't be
                              able to use while, until, eval or do$0 for the
                              loops but have to use redo. That costs a few
                              bytes but less than having to do my own split
$i/                      >3   The previous regex replacement always
                              returns 64 and each time through the loop $i is
                              increased by 64. So if this division reaches
                              4 all rotations have been done

/(.)((.|\H{6}|\H{9})\1|\H{7}\1.)\1/ This is the 4 regexes mentioned above
  ||redo                      Stop the loop if the regex matches or we
                              rotated 4 times
$_=$1?yes:n.o                If the regex matched $1 will be one of the
                              color digits (which cannot be 0) and this will
                              assign "yes" to $_. If the regex didn't match
                              in 4 times $1 will get its value from the last
                              succesful regex in scope which will be the one
                              from the rotation, but that one doesn't have
                              any () so $1 will be unset. So in case there
                              is no move $_ will be set to "no" (which needs
                              to be constructed because "no" is a keyword)

Python3，314B

import itertools as T,copy
r=[]
K=range(8)
J=[list(input())for w in K]
P=T.product
f=lambda A:["yes"for b in[A[m][n:]for m,n in P(K,K[:6])]if b[0]==b[1]==b[2]]
for i,j,x in P(K,K,[0,1]):
 t=j+1-x
 if i+x<8and t<8:B=copy.deepcopy(J);B[i][j],B[i+x][t]=B[i+x][t],B[i][j];r+=f(B)+f(list(zip(*B)))
r+=["no"]
print(r[0])

更改第6行的8、5和第9行的8s以处理任意大的输入大小；也不在乎每个值是什么，因此您可以提供它：

absdefgh
sdkljahs
lsdfjasd
fjdhsdas
dkjhfasd
sdfhaskd
sdkfhkas
weriuwqe

它将返回yes。

注解

import itertools as T,copy 
            # itertools.product is going to save us lots of for loops
r=[]        # result
K=range(8)  # we can use range(8) everywhere, so this saves more than the usual R=range
J=[list(input())for w in K] 
            # input handling: keep everything as a length-1 string to avoid map(int,input())
P=T.product
f=lambda A:["yes"for b in[A[m][n:]for m,n in P(K,K[:6])]if b[0]==b[1]==b[2]] 
            # check the condition horiontally only. K[:6] is the same as range(5)
            # A[m][n:n+3] would be neater, but not actually needed
for i,j,x in P(K,K,[0,1]): 
            # <3 itertools.product! 3 for-loops without it.
            # NB we're only going right and downwards
 t=j+1-x
 if i+x<8and t<8: 
            # don't want out-of-bounds errors at the edges
  B=copy.deepcopy(J) 
            # preserve the reference array
  B[i][j],B[i+x][t]=B[i+x][t],B[i][j] 
            # do the switch
  r+=f(B)+f(list(zip(*B))) 
            # do the test. you could end up with lots of 'yes's in r.
            # zip(*B) takes the transpose, so that f checks the columns too
r+=["no"]   # happens to ensure that r is nonempty
print(r[0]) # only prints no if r was empty before the last line

GNU sed 255 + 2 = 257B

我以为这不会像python那样好，但现在是：-/今天我已经无法上网了，所以我全神贯注于在sed中解决这个问题:)。需要使用-r标志来调用，即sed -rf command.sed < input我在乐谱上加了2。

:a
$!N
s/\n/ /g
ta
:b
/^((\w)(\w\2\2|\2\w\2|\w\2\w* \w\2|\2\w* \w\w\2|\w* (\2\w* \w* \2|\w* \2\w* \2|\w\2\2|\w\2\w* \2|\2\w* \w\2|\w\2\w* \w\2))|\w((\w)(\w* \6\w\6|\6\w* \6|\w* (\6\w \w\6|\w\6\w* \6|\6\w* \6))|\w(\w)\w* \9\9))/c\yes
s/\w(\w*)/\1/g
tb
c\no

怎么运行的：

1. 将网格读取为一行以空格分隔的字符
2. 使用motherload正则表达式找出第一列中是否存在匹配项*-如果是，则将整行替换为“是”（结束程序）
3. 删除每列中的第一个字符，然后转到2
4. 如果我们不这样做（该行为空），则将整个行替换为“ no”

Ruby，201个字节

令我失望的是没有看到没有使用正则表达式或蛮力的解决方案（尽管这些很棒），所以我写了一个。它在STDIN上接受输入。

核心的按位算术算法源自@leander 在Game Development Stack Exchange上的出色解答。

s=$<.read
$><<(?1..?9).any?{|n|a=[0]*19
s.scan(n){i=$`.size
a[i/9+1]+=2**(i%9)
a[i%9+10]+=2**(i/9)}
a.each_cons(3).any?{|x,y,z|q=y&y<<1
l=q<<1
q>>=2
y&(l<<1|q>>1)|(q|l|(y&y<<2)>>1)&(x|z)>0}}?"yes":"no"

Ruby lambda，181个字节

在这里它是一个lambda，它接受一个字符串并返回trueor false：

->s{(?1..?9).any?{|n|a=[0]*19
s.scan(n){i=$`.size
a[i/9+1]+=2**(i%9)
a[i%9+10]+=2**(i/9)}
a.each_cons(3).any?{|x,y,z|q=y&y<<1
l=q<<1
q>>=2
y&(l<<1|q>>1)|(q|l|(y&y<<2)>>1)&(x|z)>0}}}

在repl.it上查看：https ://repl.it/ColJ/2

脱节和解释

->s{
  (?1..?9).any? {|n|
    a = [0] * 19

    s.scan(n) {
      i = $`.size
      a[i/9+1] += 2**(i%9)
      a[i%9+10] += 2**(i/9)
    }

    a.each_cons(3).any? {|x,y,z|
      q = y & y << 1
      l = q << 1
      q >>= 2
      y & (l << 1 | q >> 1) |
        (q | l | (y & y << 2) >> 1) &
        (x | z) > 0
    }
  }
}

该代码在数字“ 1”到“ 9”之间进行迭代。每次迭代都有两个离散步骤：

第一步是电路板转换，您可以s.scan(n)在非高尔夫代码的代码块中看到。通过将匹配的数字视为二进制字符串，将匹配的数字视为1，将所有其他数字视为0，从而将电路板转换为8个整数的数组，每行一个。例如，以row 12231123。在第一次迭代中，这将成为二进制字符串10001100（所有1变为-er，stay-1s，所有其他数字变为0s），即十进制数140。在第二次迭代中，同一行变为01100010（所有2s变为2s，并且所有其他数字变为0）或十进制98。

它同时执行第二个转换，该转换与第一个相同，但板旋转了90度。这使我们可以使用与垂直匹配相同的逻辑来进行水平匹配。为简单起见，它将两块板连接成一个长的单块，在开头，中间（以分隔两块板）和结尾处填充零。

第二步是搜索可能的匹配项，您可以在each_cons(3).any?块中看到该匹配项。使用位算术将转换后的行（现在是8位整数）以三行（x，y，z）的组（重叠）进行检查。每个组进行检查，看是否匹配可以在排进行ÿ，无论是通过在移位行一块ý或通过一块移位到ý从X或ž。由于原始板和旋转板的行之前和之后的“行”均为零，因此我们不必检查我们在板的第一行还是最后一行。

如果没有找到匹配项，它将继续进行下一个迭代。