Có tồn tại một trò chơi não gọi là liệt kê (mà tôi thực hiện, dựa trên Takuzu ). Thử thách của bạn là chơi game này.

Bài tập

Giải quyết một trò chơi của Enum Cả / Takuzu.

• Nhận lưới bắt đầu thông qua STDIN hoặc dòng lệnh.
• Xuất lưới đã giải quyết thông qua STDOUT hoặc ghi vào tệp.

Quy tắc

Một trò chơi được đặc trưng bởi một bảng 4 x 4, được tạo thành từ các ô màu đỏ và tím.

• Phải có cùng số lượng ô màu đỏ và màu tím trong mỗi hàng và cột (mỗi ô 2 màu đỏ và 2 màu tím).

• Không được có hàng hoặc cột giống hệt nhau.

Đầu vào

Lưới bắt đầu sẽ được cung cấp như là một chuỗi 16 ký tự / byte bao gồm chỉ 0, 1và 2. Đây là một ví dụ:

0001100002001200

1đại diện cho một tế bào màu đỏ và 2đại diện cho một tế bào màu tím. Tất cả các bảng đầu vào sẽ được giải quyết.

Lưu ý: Nếu ngôn ngữ của bạn không hỗ trợ đầu vào chuỗi ký tự , bạn có thể lấy đầu vào dưới dạng một mảng số nguyên. Xin nêu trong câu trả lời của bạn rằng đây là trường hợp. Vì vậy, không có nhầm lẫn, đây là những gì nói mảng nên như thế nào:

[0, 0, 0, 1, 1, 0, 0, 0, 0, 2, 0, 0, 1, 2, 0, 0]

Không có mảng lồng nhau được cho phép.

Đầu ra

Bảng đã giải quyết phải là đầu ra có cùng định dạng như trên; một chuỗi 16 ký tự / byte, chỉ bao gồm 1và 2. Đây là giải pháp cho đầu vào ở trên:

2121112222111212

Một lần nữa, 1đại diện cho một ô màu đỏ và 2đại diện cho một ô màu tím.

Tiền thưởng

Phần thưởng -25 byte được cung cấp cho bất kỳ câu trả lời nào đưa ra bảng đã giải dưới dạng lưới ASCII. Dưới đây là một ví dụ về bảng đã đề cập trước đó.

2|1|2|1
-+-+-+-
1|1|2|2
-+-+-+-
2|2|1|1
-+-+-+-
1|2|1|2

Phần thưởng -50 byte được cung cấp cho bất kỳ câu trả lời nào xuất ra bảng đã giải có màu. Đây có thể là đầu ra dưới dạng hình ảnh hoặc văn bản màu.

Nếu văn bản màu được chọn, đầu ra sẽ như thế này:

2121
1122
2211
1212

Tuy nhiên, nếu một hình ảnh là phương thức đầu ra được chọn, tệp kết quả phải là 20x20 pixel, trong đó mỗi ô là một khối 5x5 pixel được tô màu. Đây là một ví dụ:

Dưới đây là các mã màu:

Red      -   #a73cba   OR   (167,  60, 186)
Purple   -   #f94a32   OR   (249,  74,  50)

Mẫu

In:  0020010100000100
Out: 1221212112122112

In:  0010000200121000
Out: 2211112221121221

In:  1000100102000000
Out: 1122122122112112

CJam (điểm 13)

Với phần thưởng văn bản màu, chỉ các ký tự có thể in: 64 ký tự - 50 = 14

l:~:L,Eb2*e!4m*_:z&{_M*L1$.e|.=1-!*_&,4=},~{27c'[@_4*27+'m@}f%N*

Điều này có thể được cải thiện bởi một char bằng cách sử dụng một ký tự không in được: 27c'[@trở thành "^["\nơi ^đại diện cho ký tự 27, cho số điểm là 13. phiên bản xxd:

0000000: 6c3a 7e3a 4c2c 4562 322a 6521 346d 2a5f  l:~:L,Eb2*e!4m*_
0000010: 3a7a 267b 5f4d 2a4c 3124 2e65 7c2e 3d31  :z&{_M*L1$.e|.=1
0000020: 2d21 2a5f 262c 343d 7d2c 7e7b 221b 5b22  -!*_&,4=},~{".["
0000030: 5c5f 342a 3237 2b27 6d40 7d66 254e 2a    \_4*27+'m@}f%N* 

Giải pháp thẳng không có tiền thưởng: 42 ký tự

l:~:L,Eb2*e!4m*_:z&{_M*L1$.e|.=1-!*_&,4=},

Bản demo trực tuyến

Với tiền thưởng lưới: 59 ký tự - 25 = 34

l:~:L,Eb2*e!4m*_:z&{_M*L1$.e|.=1-!*_&,4=},~'|f*2N*'-4*'+***

Bản demo trực tuyến

Với đầu ra hình ảnh, 83 ký tự - 50 = 33. Đầu ra ở định dạng netpbm.

'P3NKSKS255Nl:~:L,Eb2*e!4m*_:z&{_M*L1$.e|.=1-!*_&,4=},~4f*M*:("§<ºùJ2":i3/f=4f*M*S*

Bản demo trực tuyến

CJam, 74-50 = 24 byte (đầu ra màu)

l:~:L;5ZbGm*{_L.-L.*:|!\[4/_z]_:::+e_6-!\__.&=**},s4/{"["\_~4*27+'m@}f%N*

Tôi không nghĩ rằng điều này là rất tốt, nhưng nó hoạt động! Hãy thử nó ở đây. Cảnh báo: chậm .

l:~:L;đọc một dòng đầu vào L. Sau đó, 5Zblà [1 2], và chúng tôi lấy sức mạnh ^thứ 16 của Cartesian ( Gm*) trong danh sách này, để có được tất cả các giải pháp có thể [[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1] [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2] ...]. Bộ lọc { },chứa logic Takuzu.

Tôi đã thêm phần thưởng đầu ra màu mã ANSI:

Điều này không hoạt động trên trang web, tất nhiên. Có một ESCbyte không thể in trong chuỗi "[".

Ruby, 196 byte

->g{[o=?1,p=?2].repeated_permutation(16).find{|x|a=x.each_slice(4).to_a
t=a.transpose
a.uniq.size==4&&t.uniq.size==4&&(a+t).all?{|y|y.count(o)==2}&&x.zip(g.chars).none?{|y|y==[o,p]||y==[p,o]}}*''}

repeated_permutationTại sao tên của bạn phải dài như vậy? -_-

Điều này chỉ đơn giản là đi qua tất cả các giải pháp có thể cho đến khi một trong số chúng phù hợp với mẫu đầu vào.

C (chức năng) (với nội dung gcc), 283

Đây dường như là một thử thách thú vị để giải quyết trong C. Khá chắc chắn rằng nó có thể được đánh gôn nhiều hơn, nhưng đây là một khởi đầu:

#define m(a,b)for(j=0;j<4;j++){l[j]=i&a<<j*b;if(__builtin_popcount(l[j])-2)goto l;for(k=0;k<j;k++)if(l[j]==l[k])goto l;}
i,j,k,l[4];f(char*s){for(i=0;i<65536;i++){m(15,4)m(4369,1)for(j=0;j<16;j++)if((!(i&1<<j)==s[j]-49)&&(s[j]!=48))goto l;for(j=0;j<16;j++)putchar(50-!(i&1<<j));l:;}}

Đầu vào được truyền dưới dạng chuỗi để hoạt động f(). Đầu ra cho STDOUT.

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

JavaScript (ES6), 263 300

g=>{[...g].map(c=>(t+=t+(c>1),u+=u+(c&1)),u=t=0);for(m=15,n=4369,i=0;i++<6e4;){for(x=y=i,s=new Set;x;x>>=4,y>>=1)[3,5,6,9,10,12,17,257,272,4097,4112,4352].map(v=>(x&m)==v|(y&n)==v&&s.add(v));if(s.size>7&!(i&u)&!(~i&t))return g.replace(/./g,c=>1+(i>>--p&1),p=16)}}

Với các hạn chế, số lượng giải pháp khả thi có vẻ nhỏ đáng ngạc nhiên: 72

Toàn bộ bảng có thể được xem như là một số 16 bit.
Các giá trị được phép cho các hàng (mặt nạ 1111): 0011, 0101, 0110 và các giá trị đảo ngược 1100, 1010, 1001

Tương tự cho các cột, chỉ với các bit mặt nạ và xen kẽ khác nhau (mặt nạ 1000100010001): 0 ... 0 ... 1 ... 1, 0 ... 1 ... 0 ... 1, 0 ... 1 ... 1 ... 0 và các giá trị đảo ngược

Lưu ý rằng cách sắp xếp bit của hàng và cột là khác nhau, vì vậy để kiểm tra tính độc đáo, bạn có thể thêm cả hàng và cột vào một tập hợp và xác minh rằng kích thước tập hợp là == 8.

Mã để liệt kê tất cả các giải pháp có thể trong một lưới 4 x 4

for(m=0xf,n=0x1111,t=i=0;i<0x10000;i++)
{
  // loop condition: row != 0, as valid values have 2 bits set in each row
  for(x=y=i,s=new Set; x; x>>=4, y>>=1) 
    [3,5,6,9,10,12,17,257,272,4097,4112,4352].map(v=>((x&m)==v||(y&n)==v)&&s.add(v))
  if (s.size==8)
    console.log(++t,i.toString(2))
}

Kiểm tra

F=g=>{ // input as a string
  [...g].map(c=>(t+=t+(c>1),u+=u+(c&1)),u=t=0);
  for(m=15,n=4369,i=0;i++<6e4;) // max valid is 51862
  { 
    for(x=y=i,s=new Set;x;x>>=4,y>>=1)
      [3,5,6,9,10,12,17,257,272,4097,4112,4352].map(v=>(x&m)==v|(y&n)==v&&s.add(v));
    if(s.size>7&!(i&u)&!(~i&t))
      return g.replace(/./g,c=>1+(i>>--p&1),p=16) 
  }
}  

// Basic test

console.log=x=>O.textContent+=x+'\n'

;[
['0020010100000100','1221212112122112'],
['0010000200121000','2211112221121221'],
['1000100102000000','1122122122112112']
].forEach(t=>{
  var i = t[0], x=t[1], r=F(i);
  console.log(i+' -> '+r+(r==x?' OK':' Fail (Expected '+x+')'))
})

<pre id=O></pre>

C, Điểm 278 257

^{( 328 307 byte - 50 byte cho đầu ra màu hoặc 291 byte không có phần thưởng màu)}

t,b,c,u,r,p;v(g){for(b=0,u=59799;b<16;b+=4)u&(c=1<<(g>>b&15))?b=u:0,u|=c;return b>16;}main(i,a)char**a;{for(char*A=a[1];*A;p=p*2|*A++>49)r=r*2|*A==49;for(;++i<6e4;t=0){for(b=16;b--;)t|=(i>>b&1)<<b%4*4+b/4;if(!(p&i^p|r&~i^r|v(i)|v(t))){for(b=16;b--;)printf("\x1b[3%s%s",i&1<<b?"5m2":"1m1",b&3?"":"\n");break;}}}

Đây là một phương pháp brute-force in lưới phù hợp đầu tiên. Nó thực sự hoạt động trên lưới xoay 180 độ để đơn giản hóa một số vòng lặp và sử dụng bảng tra cứu (59799) để tìm ra hàng nào hợp lệ. Bên trong tất cả các lưới chỉ là số 16 bit. Nó nhận một đầu vào chuỗi từ các đối số của nó.

Do mã thoát được sử dụng để tô màu, bạn có thể muốn đặt lại kiểu dáng thiết bị đầu cuối của mình sau khi chạy (thực thi printf "\x1b[0m")

Phá vỡ:

// Globals initialise to 0
t, // Transpose of current guess
b, // Bit counter for loops
c, // Current row value when validating
u, // Invalid row mask when validating
r, // Red squares mask (1s in input)
p; // Purple squares mask (2s in input)

// Validation function for rows (returns 0 if valid, shell-style)
v(g){
    for(b=0,u=59799;b<16;b+=4) // "magic" value 59799 is a map of invalid rows
        // For each row:
        u&(c=1<<(g>>b&15))?b=u:0,  // Check if row is valid
        u|=c;                      // Add row to mask (rows cannot be duplicates)
    return b>16; // b = <some massive number> + 4 if a check failed
}

main(i,a)char**a;{ // K&R style function declaration to save 2 bytes
    // Read input (in reverse to save some bytes when reading & printing)
    for(char*A=a[1];*A;
        p=p*2|*A++>49) // Find 2s (input is strictly 012) and go to next
        r=r*2|*A==49;  // Find 1s
    for(;++i<6e4;t=0){ // Brute-force grids (<3 and >=60000 are invalid anyway)
        for(b=16;b--;)t|=(i>>b&1)<<b%4*4+b/4; // Calculate transpose
        if(!(                           // Check...
            p&i^p|                      //  Matches input purples
            r&~i^r|                     //  Matches input reds
            v(i)|                       //  Rows are valid
            v(t)                        //  Columns are valid
        )){
            // Display grid (use ANSI escape codes for colour)
            for(;b--;) // b starts at 16 from last v() call
//              printf(b&3?"%c":"%c\n",(i>>b&1)+49); // no colour variant
                printf("\x1b[3%s%s",i&1<<b?"5m2":"1m1",b&3?"":"\n");
            break; // Stop search
        }
    }
}

Vậy 59799 là gì?

Chỉ có 16 trạng thái có thể có cho mỗi hàng / cột (đó là số nhị phân 4 bit). Trong số đó, các tùy chọn hợp lệ là:

0011 =  3 (decimal)
0101 =  5
0110 =  6
1001 =  9
1010 = 10
1100 = 12

Lấy các giá trị đó làm chỉ mục bit, chúng ta có thể tạo mặt nạ:

0001011001101000 = 5736 (dec)

Nhưng ở đây chúng tôi muốn biết các hàng không hợp lệ :

1110100110010111 = 59799 (dec)