Nếu bạn không biết nữ hoàng trong cờ vua là gì, điều đó không quan trọng lắm; nó chỉ là một cái tên :)

Đầu vào của bạn sẽ là một hình vuông có chiều rộng và chiều cao tùy ý chứa một số lượng kiến ​​chúa. Bảng đầu vào sẽ trông như thế này (bảng này có chiều rộng và chiều cao là 8):

...Q....
......Q.
..Q.....
.......Q
.Q......
....Q...
Q.......
.....Q..

Có 8 nữ hoàng trên bảng này. Nếu có, giả sử, 7, hoặc 1 hoặc 10 ở đây, bảng sẽ không hợp lệ.

Ở đây chúng tôi sử dụng một .cho một không gian trống, và Qcho một nữ hoàng. Thay vào đó, bạn có thể sử dụng bất kỳ ký tự không phải khoảng trắng nào bạn muốn.

Đầu vào này có thể được xác minh là hợp lệ và bạn nên in (hoặc trả lại) một giá trị trung thực (nếu nó không hợp lệ, bạn nên in (hoặc trả lại) một giá trị giả). Nó là hợp lệ vì không có nữ hoàng trong cùng một hàng, cột, đường chéo hoặc chống chéo như khác .

Ví dụ (không xuất ra những thứ trong ngoặc):

...Q....
......Q.
..Q.....
.......Q
.Q......
....Q...
Q.......
.....Q..

1

...Q.
Q....
.Q...
....Q
..Q..

0

Q.
Q.

0

..Q
...
.Q.

0 (this is 0 because there are only 2 queens on a 3x3 board)


..Q.
Q...
...Q
.Q..

1

Q

1 (this is valid, because the board is only 1x1, so there's no queen that can take another)

Hãy để tôi nhấn mạnh rằng một đầu vào chỉ có giá trị, nếu không có nữ hoàng trong cùng một hàng, cột, đường chéo hoặc chống chéo như khác .

Quy tắc

• Bạn sẽ không bao giờ nhận được một đầu vào trống
• Nếu đầu vào chứa ít kiến ​​trúc hơn gốc sqaure của khu vực bảng, thì nó không hợp lệ.
• Lưu ý không có giải pháp hợp lệ cho bảng 2x2 hoặc 3x3, nhưng có một giải pháp cho mọi bảng vuông kích thước khác , trong đó chiều rộng và chiều cao là một số tự nhiên.
• Đầu vào có thể ở bất kỳ định dạng hợp lý nào, theo quy tắc PPCG
• Đầu vào sẽ luôn là một hình vuông
• Tôi đã sử dụng 1 và 0 trong các ví dụ, nhưng bạn có thể sử dụng bất kỳ giá trị trung thực hoặc giả mạo nào (chẳng hạn như Why yes, sir, that is indeed the casevà Why no, sir, that is not the case)

Vì đây là môn đánh gôn , mã ngắn nhất sẽ thắng!

Ốc , 14 byte

&
o.,\Q!(z.,\Q

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

Không có gì giống như ngôn ngữ khớp mẫu 2D cho một vấn đề quyết định 2D. :)

Giải trình

Trên &dòng đầu tiên là một tùy chọn chế độ khớp, yêu cầu mẫu trên dòng thứ hai khớp với mọi vị trí có thể có trong đầu vào. Nếu đó là trường hợp, chương trình in 1, nếu không nó in 0.

Đối với bản thân mẫu, lưu ý rằng có một ẩn )ở cuối.

o       ,, Move in any orthogonal direction (up, down, left or right).
.,\Q    ,, Make sure that there's a Q somewhere in that direction from the
        ,, starting position of the match.
!(      ,, After finding the Q, make sure that the following part _doesn't_ match:
  z     ,,   Move in any orthogonal or diagonal direction.
  .,\Q  ,,   Try to find another Q in a straight line.
)

Tại sao công trình này dễ thấy nhất bằng cách bắt đầu từ giao diện tiêu cực: bằng cách đảm bảo rằng không có Qđường thẳng nào khác Qmà chúng tôi đã tìm thấy, chúng tôi đảm bảo rằng không có nhiều hơn N nữ hoàng (nếu không, sẽ có là hai trong một hàng, và sẽ không thể tìm thấy những nữ hoàng này mà không tìm thấy một nữ hoàng khác). Sau đó, phần đầu tiên, đảm bảo rằng có một nữ hoàng có thể tiếp cận theo hướng trực giao từ bất kỳ vị trí nào, đảm bảo rằng có chính xác là N nữ hoàng. Nếu một người bị mất tích, sẽ có một hàng và một cột không có nữ hoàng. Bắt đầu từ giao điểm của những thứ này, sẽ không thể tìm thấy một nữ hoàng bằng cách chỉ đi theo hướng trực giao.

Jelly , 17 hoặc 15 byte

ỴµUŒD;ŒD;ZVṀ;V=1Ṃ

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

Sử dụng ‘cho một nữ hoàng và ¹cho không gian trống. (Điều này chủ yếu là hậu quả của việc cấm lấy đầu vào dưới dạng một mảng, vì nó buộc đầu vào là chuỗi; chuyển đổi chuỗi thành số nguyên là khó khăn trong Jelly, với phương pháp dễ nhất là đánh giá, và hóa ra thay vì 1 và 0, sử dụng "thêm 1" ( ‘) và "thêm 0" ( ¹) cho phép bỏ qua một số hướng dẫn tổng và bản đồ, bởi vì chúng ta có thể đếm các nữ hoàng trong danh sách bằng cách đánh giá nó.) Các giá trị trung thực và falsey là bình thường của Jelly 1và 0.

EDIT: Câu hỏi đã được thay đổi kể từ khi tôi viết câu trả lời này để cho phép lấy đầu vào làm ma trận. Điều này cho phép bỏ hàng đầu Ỵµ, tiết kiệm 2 byte. Nó cũng có thể cho phép thay đổi định dạng đầu vào thành một cái gì đó bình thường hơn, sử dụng Sđể tổng hợp hơn là Vđể đánh giá, nhưng tôi không nghĩ rằng việc lưu byte và tôi giống như định dạng thú vị này.

Giải trình

ỴµUŒD;ŒD;ZVṀ;V=1Ṃ
Ỵ                    Split on newlines.
 µ                   Set this value as the default for missing arguments.
     ;  ;            Concatenate the following three values:
  UŒD                - the antidiagonals;
      ŒD             - the diagonals;
         Z           - and the columns.
          V          Evaluate (i.e. count the queens on) all of those.
           Ṁ         Take the largest value among the results.
            ;V       Append the evaluation (i.e. queen count) of {each row}.
              =1     Compare each value to 1.
                Ṃ    Take the minimum (i.e. most falsey) result.

Vì vậy, ý tưởng cơ bản là chúng tôi đảm bảo rằng có nhiều nhất một nữ hoàng trên mỗi cột, đường chéo và cột; và chính xác một nữ hoàng trên mỗi hàng. Các điều kiện này đủ với nhau để yêu cầu có nhiều nhất một nữ hoàng trên mỗi bốn dòng, và một số nữ hoàng bằng với chiều dài cạnh của bảng.

Ngẫu nhiên, Jelly có thể có thể tích hợp sẵn cho các antidiagonals, nhưng AFAICT dường như không có, vì vậy tôi cần giải quyết để phản chiếu bảng và sau đó lấy các đường chéo.

Một lưu ý thú vị khác là việc thay đổi =1Ṃthành E(tất cả bằng nhau) mang lại một khái quát trình kiểm tra n -queens , cũng sẽ chấp nhận một bảng n × n trong đó mỗi hàng, cột, đường chéo và antidia chéo chứa không quá k Queen và bảng chứa chính xác nữ hoàng kn . Hạn chế k đến bằng 1 thực sự tốn hai byte.

Octave, 57 70 67 51 52 byte

Đã lưu 1 byte bằng cách sử dụng flipthay vì rot90cảm ơn @LuisMendo, nhưng đã tìm thấy một lỗi trên trường hợp 1x1

@(A)all(sum([A A' (d=@spdiags)(A) d(flip(A))],1)==1)

Đưa đầu vào dưới dạng ma trận nhị phân với 1 đại diện cho Nữ hoàng và 0 đại diện cho một không gian trống.

Tạo một hàm ẩn danh trước tiên ghép nối ma trận đầu vào và chuyển vị của nó.

spdiagstạo một ma trận có cùng số lượng hàng với đối số, với các đường chéo được chuyển thành cột (không đệm nếu cần), do đó, nối spdiagsma trận đầu vào để lấy các đường chéo và spdiagsma trận lật theo chiều ngang để có được các đường chéo.

Bây giờ hãy lấy tổng của từng cột của ma trận nối và đảm bảo mỗi cột chính xác là 1.

Mẫu chạy trên ideone .

MATL , 38 34 byte

Giảm 4 byte nhờ @beaker !

sG!sGt&n_w&:&XdsGP5M&Xdsv2<GnGzU=*

Đầu vào là một mảng 2D gồm các số 0 và số 0, sử dụng dấu chấm phẩy làm dấu tách hàng.

Điều này đưa ra một vectơ cột của những cái là trung thực và một vectơ cột chứa ít nhất một số 0 là giả.

Hãy thử trực tuyến!Mã chân trang là một ifnhánh để chứng minh tính trung thực hoặc giả.

Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

s      % Input binary matrix implicitly. Sum of columns. Gives a row vector
G!     % Paste input again. Transpose
s      % Sum of columns (rows in the original matrix). Gives a row vector
G      % Paste input again
t&n    % Duplicate. Push number of rows and number of columns (will be equal)
_w     % Negate, flip
&:     % Binary range. Gives [-n -n+1 ... n] for input of size n×n
&Xd    % Get diagonals -n through n. This gives all diagonals as colums
s      % Sum of each column (diagonals of original matrix). Gives a row vector
GP     % Paste input again. Flip vertically
5M     % Push [-n -n+1 ... n] again
&Xd    % Get diagonals -n through n (anti-diagonals of original matrix)
s      % Sum of each column. Gives a row vector
v      % Concatenate everything into a column vector
2<     % True for elements that are less than 2
Gn     % Paste input again. Number of elements
Gz     % Paste input again. Number of nonzeros (i.e. of queens)
U      % Square
=      % True if equal
*      % Mutiply, element-wise

J , 37 byte

(+/&,=#)*1=[:>./+//.,+//.&|.,+/,+/&|:

Hàm hàm ẩn danh lấy ma trận Boolean làm đối số.

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

( +/tổng &của ,ravel =bằng #tổng số hàng)

* và (lần)

1một =bằng [:với >./tối đa của

+/các khoản tiền /.theo đường chéo ,và (lit. catenated to)

+/các khoản tiền /.theo đường chéo &của |.đảo ngược ,và

+/các khoản tiền trên ,và

+/số tiền &của |:các transpose

SnakeEx , 67 byte

m:({q<>}({q<R>}[{q<RF>}{n<RF>}].)*{e<>}<R>)%{4}
e:.$
q:_*Q_*$
n:_+$

Công dụng _ thay thế .trong đầu vào. Trả về 1 hoặc nhiều trận đấu cho sự thật, 0 trận đấu cho falsey. Bạn có thể tìm thấy một thông dịch viên trực tuyến tại liên kết trong tiêu đề.

Giải trình

SnakeEx là một ngôn ngữ từ thử thách Kết hợp mẫu 2-D . Nó định nghĩa "rắn" di chuyển xung quanh các công cụ khớp lưới. Rắn có thể sinh ra những con rắn khác, làm cho ngôn ngữ khá mạnh mẽ.

Hãy xem chương trình này từ dưới lên.

n:_+$

Điều này định nghĩa một con rắn n khớp với 1 hoặc nhiều dấu gạch dưới và sau đó là cạnh của lưới. Lưu ý rằng điều này có thể nằm trong bất kỳ hướng nào trong 8 hướng hồng y - hướng được xác định khi rắn sinh sản.

q:_*Q_*$

Tương tự như ntrên, điều này định nghĩa qlà một con rắn phù hợp với bất kỳ số lượng dấu gạch dưới, mộtQ , bất kỳ số lượng dấu gạch dưới và cạnh của lưới. Nói cách khác, một hàng / cột / đường chéo chỉ có một nữ hoàng trong đó.

e:.$

e là một con rắn phù hợp với một nhân vật và cạnh của lưới.

m:({q<>}({q<R>}[{q<RF>}{n<RF>}].)*{e<>}<R>)%{4}

Con rắn chính m sử dụng các khối xây dựng này để kiểm tra toàn bộ bảng. Về mặt khái niệm, nó chạy quanh các cạnh bên ngoài của lưới, sinh ra những con rắn khác để kiểm tra xem tất cả các cột và hàng có chính xác một nữ hoàng và tất cả các đường chéo có nhiều nhất một nữ hoàng. Nếu bất kỳ con rắn sinh sản nào không khớp, toàn bộ trận đấu sẽ thất bại. Hãy phá vỡ nó.

• ( )%{4}chạy những gì bên trong dấu ngoặc đơn 4 lần, một lần cho mỗi bên. (Trong phần tiếp theo, thật hữu ích khi hình dung một mặt cụ thể - giả sử, cạnh trên của lưới, bắt đầu từ góc trên cùng bên trái và di chuyển sang phải.)
• {q<>}sinh ra một qcon rắn theo cùng hướng mà con rắn chính đang di chuyển. Điều này xác minh rằng cạnh hiện tại đáp ứng quy tắc "chính xác là một nữ hoàng". Lưu ý rằng những con rắn được sinh ra không di chuyển con trỏ khớp của con rắn chính, vì vậy chúng ta vẫn ở đầu của cạnh.
• ( )* khớp 0 hoặc nhiều hơn những gì bên trong dấu ngoặc đơn.
• {q<R>}sinh ra một qcon rắn quay phải từ hướng của con rắn chính. (Ví dụ: nếu con rắn chính đang di chuyển sang phải dọc theo cạnh trên, con rắn này di chuyển xuống dưới.) Điều này kiểm tra từng cột / hàng.
• [ ] khớp với một trong các tùy chọn bên trong ngoặc:
  • {q<RF>}sinh ra một qcon rắn quay 45 độ về phía trước (tức là Right và hướng về phía trước F) từ hướng của con rắn chính. Con qrắn phù hợp nếu đường chéo chứa chính xác một nữ hoàng.
  • {n<RF>}nThay vào đó sinh ra một con rắn. Con nrắn phù hợp nếu đường chéo không có nữ hoàng.
• . phù hợp với bất kỳ nhân vật, di chuyển con trỏ phù hợp về phía trước.
• Sau khi kiểm tra càng nhiều chiều ngang và đường chéo càng tốt, chúng tôi xác minh rằng chúng tôi đang ở rìa bằng cách sinh sản {e<>}.
• Cuối cùng, <R>xoay con rắn chính sang phải, sẵn sàng để khớp với cạnh tiếp theo.

Những thứ kỳ lạ

• Không có gì trong chương trình để đảm bảo rằng kết hợp bắt đầu ở một góc bên ngoài. Trong thực tế, các trường hợp thử nghiệm trung thực mang lại một số trận đấu, một số trong đó bắt đầu ở bên trong một nơi nào đó. Mặc dù vậy, không có trường hợp chim ưng nào tôi từng thử đã tạo ra bất kỳ kết quả dương tính giả nào.
• Nếu tôi đang đọc đúng thông số ngôn ngữ , tôi đã có thể sử dụng X(nhánh theo tất cả các hướng chéo) thay cho RF. Thật không may, thông dịch viên trực tuyến nói rằng đó là một lỗi cú pháp. Tôi cũng đã thử *(chi nhánh theo mọi hướng), nhưng điều đó treo thông dịch viên.
• Về mặt lý thuyết, một cái gì đó giống như _*Q?_*$phải hoạt động để khớp "nhiều nhất là một nữ hoàng" trong các đường chéo, nhưng điều đó cũng treo thông dịch viên. Tôi đoán là khả năng các trận đấu trống gây ra vấn đề.

Ruby, 120 byte

Hàm Lambda dựa trên thông số ban đầu yêu cầu đầu vào dưới dạng chuỗi.

->s{t=k=0
a=[]
s.bytes{|i|i>65&&(a.map{|j|t&&=((k-j)**4).imag!=0};a<<k)
k=i<11?k.real+1:k+?i.to_c}
t&&~a.size**2>s.size}

chuyển đổi Q thành số phức và trừ chúng với nhau. Nếu sự khác biệt giữa tọa độ của bất kỳ hai kiến ​​trúc nào là ngang, dọc hoặc chéo, nâng nó lên sức mạnh thứ 4 sẽ mang lại một số thực và sự sắp xếp không hợp lệ.

Ungolfed trong chương trình thử nghiệm

f=->s{                                 #Take input as string argument.
  t=k=0                                #k=coordinate of character. t=0 (truthy in ruby.)
  a=[]                                 #Empty array for storing coordinates.
  s.bytes{                             #Iterate through all characters as bytes.
    |i|i>65&&(                         #If alphabetical, compare the current value of k to the contents of a
      a.map{|j|t&&=((k-j)**4).imag!=0} #If k-j is horizontal, vertical or diagonal, (k-j)**4 will be real and t will be false
      a<<k)                            #Add the new value of k to the end of a.
    k=i<11?k.real+1:k+?i.to_c          #If not a newline, increment the imaginary part of k. If a newline, set imaginary to 0 and increment real
  }                                    #s.size should be a*a + a newlines. ~a.size = -1-a.size, so ~a.size**2 = (a.size+1)**2
t&&~a.size**2>s.size}                  #compare a.size with s.size and AND the result with t. Return value. 


p f["...Q....
......Q.
..Q.....
.......Q
.Q......
....Q...
Q.......
.....Q.."]

p f["...Q.
Q....
.Q...
....Q
..Q.."]

p f["Q.
Q."]

p f["..Q
...
.Q."]

p f["..Q.
Q...
...Q
.Q.."]

p f["Q"]

Python 3 , 232 200 155 byte

d=1
f=input()
Q=[]
for i in f:d=[0,d][i.count('Q')==1];Q+=[(len(Q),i.index('Q'))]
print[0,d][sum(k[1]==i[1]or sum(k)==sum(i)for k in Q for i in Q)==len(Q)]

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

-32 byte nhờ @beaker nhận thấy sự thay đổi trong thông số kỹ thuật đầu vào; Tôi đã thay đổi ngôn ngữ từ Python 3 thành 2, do đó cho phép tôi sử dụnginput để lấy đầu vào dưới dạng một chuỗi các chuỗi hoặc một mảng các mảng ký tự.

-45 byte nhờ @Leaky Nun

JavaScript (ES6), 115 byte

a=>!a.some((b,i)=>b.some((q,j)=>q&&h[i]|v[j]|d[i+j]|e[i-j]|!(h[i]=v[j]=d[i+j]=e[i-j]=1))|!h[i],h=[],v=[],d=[],e=[])

Ung dung:

function queens(arr) {
    horiz = [];
    vert = [];
    diag = [];
    anti = [];
    for (i = 0; i < arr.length; i++) {
        for (j = 0; j < arr.length; j++) {
            if (arr[i][j]) { // if there is a queen...
                if (horiz[i]) return false; // not already on the same row
                if (vert[j]) return false; // or column
                if (diag[i + j]) return false; // or diagonal
                if (anti[i - j]) return false; // or antidiagonal
                horiz[i] = vert[j] = diag[i + j] = anti[i - j] = true; // mark it
            }
        }
        if (!horiz[i]) return false; // fail if no queen in this row
    }
    return true;
}

Ruby, 155 byte

->x{(y=x.map{|r|(i=r.index ?Q)==r.rindex(?Q)?i:p or-2}).zip(y.rotate).map.with_index{|n,i|n.max-n.min==1&&i<y.size-1?-2:n[0]}.inject(:+)*2==(s=x.size)*~-s}

Điều này thật kinh khủng khi đọc, vì vậy tôi đã có một phiên bản ít chơi gôn hơn bên dưới

->x{
    (y=x.map{|r|(i=r.index ?Q)==r.rindex(?Q)?i:p or-2})
    .zip(y.rotate)
    .map.with_index{|n,i|n.max-n.min==1&&i<y.size-1?-2:n[0]}
    .inject(:+)*2==(s=x.size)*~-s
}

Đây là cùng một mã, nhưng với một số dòng mới để phân biệt những gì đang xảy ra.

Bản thân mã là một hàm lambda ẩn danh có một chuỗi các chuỗi ( x) ở định dạng ["..Q", "Q..", ".Q."].

Dòng đầu tiên là ánh xạ từng chuỗi vào chỉ mục của ký tự Q trong chuỗi đó. Nếu không có ký tự Q, nó được thay thế bằng -2 ¹ . Mảng chỉ số mới này được gán cho biến y.

Dòng tiếp theo nén mảng chỉ số này với chính nó được bù bởi một (xoay). Điều này dẫn đến một loạt các cặp chỉ số liên tiếp.

Dòng tiếp theo đặc biệt phức tạp. Nó đi qua từng cặp chỉ số và trừ nhỏ hơn từ lớn hơn. Nếu đây là 1 (và chúng tôi không ở cặp ² cuối cùng ), thì có hai nữ hoàng nằm trên cùng một đường chéo và giá trị -2 được chèn, nếu không thì chỉ số ban đầu của nữ hoàng trong chuỗi được chèn vào .

Dòng cuối cùng tổng hợp tất cả các chỉ mục cho mỗi và kiểm tra xem đó có phải là số tam giác cho n-1 hay không, trong đó n là chiều rộng (hoặc chiều cao) của hình vuông.

1: -1 sẽ là mục tiêu của tôi, nhưng nó cách 1 so với 0, do đó sẽ gây rối với việc kiểm tra các đường chéo. Tính chất tiêu cực của nó rất quan trọng để làm cho tổng cuối cùng sai. Tôi đã nghĩ về một số cao (có một chữ số) như 9, nhưng tôi không thể chắc chắn rằng điều đó sẽ không dẫn đến một xác minh không chính xác.
2: Bảng không quấn tròn, trong khi rotatechức năng mảng của ruby thì có, và nếu cặp cuối cùng khác nhau thì không thành vấn đề - đó không phải là đường chéo.

PHP, 137 143 byte

lấy cảm hứng từ giải pháp của Neil

for($n=1+strlen($s=$argv[1])**.5|0;($c=$s[$p])&&!(Q==$c&&$v[$x=$p%$n]++|$h[$x=$p/$n]++|$d[$y-$x]++|$a[$y+$x]++);$p++);echo$n-1==count($a)&&!$c;

lấy đầu vào từ đối số dòng lệnh đầu tiên; chạy với -r. Yêu cầu ngắt dòng byte đơn.
^{Trên thực tế bạn có thể sử dụng bất kỳ ký tự nào nhưng 0để ngắt dòng.}
in đúng ( 1) hoặc sai (chuỗi trống).

phá vỡ

for($n=1+strlen($s=$argv[1])**.5|0; // copy input to $s, $n=size+1 (for the linebreak)
    ($c=$s[$p])&&!(                 // loop through characters
        Q==$c&&                         // if queen: test and increment lines
            $v[$x=$p%$n]++|$h[$x=$p/$n]++|$d[$y-$x]++|$a[$y+$x]++
    );                                  // break if a line had been marked before
    $p++);
echo$n-1==count($a)             // print result: true for $n-1(=size) marks
    &&!$c;                      // and loop has finished

Python 3 , 185 176 175 172 171 byte

lambda x,c=lambda x:x.count("Q")==1:all([*map(c,x+[[l[i]for l in x]for i in range(len(x[0]))])])*~any(map(lambda s:"Q%sQ"%(s*".")in"".join(x),[len(x[0]),len(x[0])-2]))==-1

Một hàm ẩn danh lấy một danh sách các chuỗi làm đầu vào.

Python 2 , 175 byte

lambda x:all([a.count("Q")==1for a in x]+[[l[i]for l in x].count("Q")==1for i in range(len(x[0]))]+[all(map(lambda s:"Q%sQ"%(s*".")not in"".join(x),[len(x[0]),len(x[0])-2]))])