Lý lịch

Trong các trò chơi Bejeweled và tương tự, người chơi phải hoán đổi bất kỳ hai viên đá quý liền kề (không có đường chéo) trong một lưới đá quý 8 x 8 để khớp ba màu cùng một hàng. Các đá quý có thể được kết hợp theo chiều ngang hoặc chiều dọc. Trò chơi tiếp tục cho đến khi không có di chuyển nào tồn tại có thể được thực hiện dẫn đến ba liên tiếp, tại thời điểm trò chơi kết thúc.

Bài tập

Mục tiêu là viết một chương trình xác định xem một trò chơi của Bejeweled chưa kết thúc. Nói cách khác, nó phải kiểm tra xem liệu có một động thái nào có thể thực hiện ít nhất ba lần liên tiếp hay không. Có thể có nhiều hơn ba viên đá quý liên tiếp và nó vẫn là một nước đi hợp lệ.

Đầu vào

Chương trình của bạn phải chấp nhận thông qua đầu vào tiêu chuẩn một đại diện 8 x 8 của lưới Bejeweled. Mỗi trong số bảy màu đá quý sẽ được biểu thị bằng một chữ số từ 1 đến 7. Mỗi dòng sẽ chứa một hàng và 8 dòng, mỗi dòng gồm 8 chữ số sẽ được nhập vào. Xem các ví dụ. Bạn có thể giả định rằng đầu vào sẽ luôn tuân theo định dạng này và sẽ không bao giờ chứa ba liên tiếp.

Đầu ra

Sau đó, chương trình phải xuất ra (thành đầu ra tiêu chuẩn) yeshoặc notùy thuộc vào việc có tồn tại ít nhất một di chuyển hợp lệ hay không sẽ dẫn đến ba hoặc nhiều viên đá quý liên tiếp. Chương trình của bạn không được xuất bất cứ thứ gì ngoài một phiên bản duy nhất yeshoặc no.

Quy tắc

Chương trình của bạn không được sử dụng bất kỳ tệp hoặc tài nguyên bên ngoài, đối số dòng lệnh hoặc yêu cầu một tên tệp nhất định. Chương trình có số byte ít nhất trong mã nguồn của nó sẽ thắng.

Ví dụ

Đầu vào:

12314131
13224145
54762673
61716653
61341144
23453774
27645426
75575656

Đầu ra: yes

Đầu vào:

35261546
76421754
15743271
62135642
35617653
64565476
54427254
15635465

Đầu ra: no

Xem câu trả lời của MT0 bên dưới để biết thêm các trường hợp thử nghiệm.

Giải pháp gốc: JavaScript - 261 255 228 227 179 153 Ký tự

/(\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'

Giả sử rằng chuỗi cần kiểm tra nằm trong biến s(để biến nó thành hàm fsau đó thêm f=s=>vào phần đầu của mã hoặc, nếu không, để lấy đầu vào từ một dấu nhắc sau đó thay thế sbằng prompt()).

Đầu ra là vào bàn điều khiển.

Giải pháp ^thứ 3 : JavaScript (ECMAScript 6) - 178 ký tự

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'

Tôi đã lấy giải pháp ^{thứ 2} , bên dưới, (sử dụng các biểu thức thông thường để kiểm tra các ký tự trong các cấu hình nhất định) và làm lại nó để chỉ kiểm tra chuỗi cho các ký tự giống hệt nhau trong cùng cấu hình mà không sử dụng các biểu thức thông thường.

Chuỗi Base-36 "2313ab1b8a2a78188h9haj9j8iaiir9r"mang đến cho các cặp offsets để kiểm tra - tức là cặp 23kết quả trong việc kiểm tra nếu tôi ^thứ nhân vật giống với (i + 2) ^thứ nhân vật và (i + 3) ^{lần thứ} ký tự (tương đương với biểu thức chính quy(.).\1\1 - với một số kiểm tra bổ sung để đảm bảo rằng ký tự không giống nhau không phải là một dòng mới).

2 ^nd Giải pháp: JavaScript (ECMAScript 6) - 204 Nhân vật

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'

Xây dựng nhiều biểu thức chính quy (xem bên dưới để biết thêm chi tiết) bằng cách sử dụng các cặp giá trị được lấy từ chuỗi Base-18 10907160789879h8và thực hiện ORtất cả các bài kiểm tra. Để giảm thêm, bạn có thể lưu ý rằng các biểu thức chính quy đi theo cặp trong đó một biểu thức là "đảo ngược" của biểu thức khác (bỏ qua Biểu thức chính quy cho 3 hàng liên tiếp theo chiều ngang và chiều dọc như trạng thái OP sẽ không bao giờ xuất hiện - nếu bạn muốn thêm các thử nghiệm đó trở lại trong phần bổ sung 0088vào chuỗi Base-18).

Giải trình

Bắt đầu với 16 biểu thức chính quy bao gồm tất cả các cấu hình có thể có của các bước di chuyển hợp lệ:

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

( Lưu ý: các regexs cho 3 trong một hàng ngang (0 ^ngày ) và theo chiều dọc (một phần của 9 ^ngày ) không liên quan như các tiểu bang OP mà đầu vào phù hợp với những sẽ không bao giờ có mặt. )

Việc kiểm tra từng cái dựa trên đầu vào sẽ xác định xem có thể tìm thấy di chuyển hợp lệ của cấu hình đó hay không.

Tuy nhiên, các biểu thức chính quy có thể được kết hợp để đưa ra 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

Chúng sau đó có thể được kết hợp thành một biểu thức chính quy duy nhất:

/(\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/

Mà chỉ cần được kiểm tra đối với đầu vào.

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

Một số trường hợp thử nghiệm mà người khác có thể thấy hữu ích (không tuân thủ định dạng đầu vào chỉ sử dụng các chữ số 1-7 nhưng điều đó dễ dàng sửa chữa và chỉ là lưới 8x4 - vì đó là yêu cầu tối thiểu để kiểm tra tất cả các đầu vào hợp lệ ).

Trong định dạng của bản đồ từ chuỗi đầu vào tới 16 biểu thức chính quy ở trên phù hợp.

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

Chỉnh sửa 1

Thay \ds bằng .- lưu 6 ký tự.

Chỉnh sửa 2

Thay thế (?:.|\n)bằng [\s\S]và loại bỏ nhóm phi chụp thêm và tham khảo lại được cập nhật (theo đề nghị của m-Buettner ) và được thêm vào trong có / không có đầu ra.

Chỉnh sửa 3

• Đã thêm giải pháp ECMAScript 6 để xây dựng các Biểu thức chính quy riêng lẻ từ chuỗi Base-18.
• Đã xóa các bài kiểm tra cho 3 hàng liên tiếp theo chiều ngang (như được đề xuất bởi m-buettner ).

Chỉnh sửa 4

Đã thêm một giải pháp (ngắn hơn) và hai trường hợp kiểm tra không phù hợp hơn.

Chỉnh sửa 5

• Rút ngắn giải pháp ban đầu bằng cách thay thế các dòng mới bằng một ký tự không phải là số (như được đề xuất bởi VadimR ).

Chỉnh sửa 6

• Rút ngắn giải pháp ban đầu bằng cách kết hợp các bit của biểu thức chính quy (như được đề xuất bởi VadimR ).

Con trăn 383

Chỉ là một dòng * Python duy nhất!

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

* Chà, với dấu chấm phẩy, nhưng điều đó vẫn không tầm thường ở con trăn (con trăn một lớp rất thú vị! )

Node.js - Giải pháp ngây thơ - 905 byte

Chà, chưa có câu trả lời nào nên tôi sẽ đăng một giải pháp thực sự ngây thơ trong Node.js

Nó đi qua mọi di chuyển có thể và sau đó kiểm tra bảng kết quả để xem nếu có 3 liên tiếp.

Đã chơi gôn (với trình biên dịch đóng google) (một số nội dung hacky trong đó như! 0 và! 1; Tôi thậm chí không chắc chắn những gì nó đã làm với trao đổi XOR của mình)

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

Lưu ý rằng tôi đã viết tất cả những điều này trên điện thoại di động của mình và không có thời gian để kiểm tra nó hoặc bất cứ điều gì. Nhận xét nếu bạn thấy bất kỳ lỗi nào, tôi sẽ tự kiểm tra nó sau.

Phiên bản có thể đọc được của con người

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

Bao gồm + cho -a0p

Chạy với đầu vào trên 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

Điều này kết hợp một giải pháp regex ngang đơn hướng với các phép quay

Giải trình:

Trong giải pháp này, tôi sẽ liên tục xoay và thực hiện 4 bài kiểm tra sau:

/(.).\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

Trường hợp \C"bất kỳ nhân vật" (không giống như .điều này bao gồm dòng mới). Ngoại trừ việc\C không được chấp nhận và dẫn đến cảnh báo, vì vậy tôi sử dụng \H(không gian không nằm ngang) thay vào đó là đủ tốt để nắm bắt tất cả các chữ số và dòng mới.

Sau 4 vòng quay, điều này sẽ thực hiện tất cả 16 bài kiểm tra cần thiết

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

Thay đổi 8, 5 trên dòng 6 và 8 trên dòng 9 để xử lý các kích thước đầu vào lớn tùy ý; cũng không quan tâm mỗi giá trị là gì, vì vậy bạn có thể cung cấp cho nó:

absdefgh
sdkljahs
lsdfjasd
fjdhsdas
dkjhfasd
sdfhaskd
sdkfhkas
weriuwqe

và nó sẽ trở lại yes .

Chú thích

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

Tôi nghĩ rằng điều này sẽ không tốt bằng python nhưng bây giờ: - / Tôi đã không có truy cập internet ngày hôm nay vì vậy tôi đã tự mình giải quyết vấn đề này trong sed :). Cần được gọi với cờ -r, sed -rf command.sed < inputvì vậy tôi đã thêm 2 vào điểm số của mình.

: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

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

1. Đọc lưới thành một dòng các ký tự được phân tách bằng dấu cách
2. Sử dụng biểu thức mẹ tải để tìm hiểu xem có khớp trong cột đầu tiên * - nếu có, hoán đổi toàn bộ dòng thành 'có' (kết thúc chương trình)
3. Tách ký tự đầu tiên từ mỗi cột và goto 2 nếu chúng ta đã làm
4. Nếu chúng tôi không (dòng trống) thay thế toàn bộ dòng bằng 'không'

Ruby, 201 byte

Tôi đã thất vọng khi không thấy bất kỳ giải pháp nào cho thử thách lớn này mà không sử dụng regex hoặc vũ phu (mặc dù đó là những giải pháp tuyệt vời), vì vậy tôi đã viết một. Nó nhận đầu vào trên STDIN.

Thuật toán số học bitwise cốt lõi được lấy từ câu trả lời tuyệt vời này trên Sàn giao dịch phát triển trò chơi của @leander.

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 byte

Đây là một lambda lấy một chuỗi và trả về truehoặc 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}}}

Xem nó trên repl.it: https://repl.it/ColJ/2

Ung dung & giải thích

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

Mã lặp qua các chữ số "1" đến "9." Mỗi lần lặp có hai bước riêng biệt:

Bước đầu tiên là chuyển đổi bảng, mà bạn có thể thấy trong s.scan(n)khối trong mã không mã hóa. Nó biến đổi bảng thành một mảng gồm 8 số nguyên, mỗi số cho mỗi hàng, bằng cách xử lý các chữ số khớp nhau là 1s và tất cả các số khác là 0 trong một chuỗi nhị phân. Ví dụ, lấy hàng 12231123. Trong lần lặp đầu tiên, chuỗi này sẽ trở thành chuỗi nhị phân 10001100(tất cả 1 số trở thành Số er, giữ lại Số 1 và tất cả các chữ số khác trở thành 0), là số thập phân 140. Trong lần lặp thứ hai, cùng một hàng trở thành 01100010(tất cả 2 đều trở thành 2 và tất cả các chữ số khác trở thành 0) hoặc thập phân 98.

Nó đồng thời thực hiện một phép biến đổi thứ hai, giống như lần đầu tiên nhưng với bảng xoay 90 độ. Điều này cho phép chúng tôi sử dụng logic tương tự để tạo các kết hợp ngang như dọc. Để đơn giản, nó ghép hai bảng thành một bảng dài duy nhất có số 0 ở đầu, giữa (để tách hai bảng) và kết thúc cho phần đệm.

Bước thứ hai là tìm kiếm các kết quả phù hợp mà bạn có thể thấy trong each_cons(3).any?khối. Các hàng được chuyển đổi (hiện là số nguyên 8 bit) được kiểm tra trong các nhóm (chồng chéo) gồm ba hàng ( x , y , z ) bằng số học bitwise. Mỗi nhóm được kiểm tra xem liệu một trận đấu có thể được thực hiện trong hàng y hay không , bằng cách chuyển một mảnh trong hàng y hoặc bằng cách chuyển một mảnh thành y từ x hoặc z . Vì không có "hàng" nào trước và sau cả hai hàng ban đầu và bảng xoay, chúng tôi không phải kiểm tra xem chúng tôi ở hàng đầu tiên hay cuối cùng của bảng.

Nếu không có kết quả khớp nào được tìm thấy, nó sẽ tiếp tục lặp lại tiếp theo.