หากคุณไม่รู้ว่าราชินีคืออะไรในหมากรุกมันไม่สำคัญอะไรนัก มันเป็นเพียงชื่อ :)

การป้อนข้อมูลของคุณจะเป็นรูปสี่เหลี่ยมจัตุรัสกว้างและความสูงโดยพลการที่มีจำนวนควีนส์ บอร์ดอินพุตจะมีลักษณะเช่นนี้ (บอร์ดนี้มีความกว้างและความสูง 8):

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

บอร์ดนี้มี 8 ควีนส์ ถ้ามีพูด 7 หรือ 1 หรือ 10 ที่นี่บอร์ดจะไม่ถูกต้อง

ที่นี่เราใช้.สำหรับพื้นที่ว่างและQสำหรับราชินี คุณอาจใช้อักขระที่ไม่ใช่ช่องว่างที่คุณต้องการแทนก็ได้

อินพุตนี้สามารถตรวจสอบได้ว่าถูกต้องและคุณควรพิมพ์ (หรือส่งคืน) ค่าจริง (หากไม่ถูกต้องคุณควรพิมพ์ (หรือส่งคืน) ค่าเท็จ มันเป็นความถูกต้องเพราะไม่มีพระราชินีอยู่ในแถวเดียวกันคอลัมน์ขวางหรือแนวทแยงต่อต้านอีก

ตัวอย่าง (อย่าแสดงสิ่งที่อยู่ในวงเล็บ):

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

ผมขอเน้นว่าการป้อนข้อมูลที่ถูกต้องเท่านั้นถ้าไม่มีพระราชินีอยู่ในแถวเดียวกันคอลัมน์ขวางหรือแนวทแยงต่อต้านอีก

กฎระเบียบ

• คุณจะไม่ได้รับการป้อนข้อมูลที่ว่างเปล่า
• หากอินพุตมีคิวน้อยกว่ารูต sqaure ของพื้นที่ของบอร์ดแสดงว่าไม่ถูกต้อง
• โปรดทราบว่าไม่มีวิธีแก้ปัญหาที่ถูกต้องสำหรับบอร์ด 2x2 หรือ 3x3 แต่มีวิธีแก้ปัญหาสำหรับบอร์ดสี่เหลี่ยมจัตุรัสขนาดอื่น ๆที่มีความกว้างและความสูงเป็นจำนวนธรรมชาติ
• อินพุตอาจอยู่ในรูปแบบที่เหมาะสมตามกฎของ PPCG
• การป้อนข้อมูลจะเป็น sqaure
• ฉันใช้ 1 และ 0 ในตัวอย่าง แต่คุณสามารถใช้ค่าจริงหรือเท็จใด ๆ (เช่นWhy yes, sir, that is indeed the caseและWhy no, sir, that is not the case)

เช่นนี้เป็นรหัสกอล์ฟรหัสที่สั้นที่สุดชนะ!

หอยทากขนาด 14 ไบต์

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

ลองออนไลน์!

ไม่มีอะไรที่เหมือนกับภาษาจับคู่รูปแบบ 2D สำหรับปัญหาการตัดสินใจ 2D :)

คำอธิบาย

&ในบรรทัดแรกเป็นตัวเลือกโหมดการแข่งขันซึ่งจะต้องมีรูปแบบในบรรทัดที่สองเพื่อให้ตรงจากตำแหน่งเป็นไปได้ทุกในการป้อนข้อมูล หากเป็นเช่นนั้นโปรแกรมจะพิมพ์1มิฉะนั้นจะพิมพ์0ออกมา

สำหรับรูปแบบของตัวเองโปรดทราบว่ามี)จุดสิ้นสุดที่สิ้นสุด

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

เหตุใดงานนี้ง่ายที่สุดที่จะเห็นโดยเริ่มต้นจาก lookahead เชิงลบ: โดยตรวจสอบให้แน่ใจว่าไม่มีQเส้นตรงจากที่อื่นที่Qเราพบแล้วเราตรวจสอบให้แน่ใจว่ามีไม่เกินNควีน (ไม่เช่นนั้นจะมี เป็นสองในแถวเดียวและจะไม่สามารถหาราชินีเหล่านี้ได้หากไม่พบอีกแถว) จากนั้นส่วนแรกเพื่อให้แน่ใจว่ามีการเข้าถึงพระราชินีในทิศทางที่ตั้งฉากจากตำแหน่งใด ๆ ทำให้แน่ใจว่ามีตรงNราชินี หากมีใครหายไปจะมีแถวและคอลัมน์ที่ไม่มีราชินี เริ่มต้นจากจุดตัดของสิ่งเหล่านี้มันเป็นไปไม่ได้ที่จะหาราชินีโดยไปในทิศทางตั้งฉากเท่านั้น

เยลลี่ , 17 หรือ 15 ไบต์

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

ลองออนไลน์!

ใช้‘สำหรับราชินีและ¹พื้นที่ว่าง (นี่เป็นผลมาจากการห้ามใช้อินพุตเป็นอาเรย์เนื่องจากมันบังคับให้อินพุตเป็นสตริงการแปลงสตริงเป็นจำนวนเต็มเป็นเรื่องยากในเจลลี่ด้วยวิธีที่ง่ายที่สุดในการประเมินผลและปรากฎว่าแทนที่จะเป็น 1 และ 0 โดยใช้ "เพิ่ม 1" ( ‘) และ "เพิ่ม 0" ( ¹) ทำให้ไม่สามารถรวมคำแนะนำและแผนที่ได้เนื่องจากเราสามารถนับราชินีในรายการโดยการประเมินค่า) ความจริงและเท็จเป็นค่าปกติของเยลลี่1และ0.

แก้ไข: คำถามมีการเปลี่ยนแปลงตั้งแต่ฉันเขียนคำตอบนี้เพื่อให้การป้อนข้อมูลเป็นเมทริกซ์ สิ่งนี้จะช่วยให้การวางชั้นนำỴµประหยัด 2 ไบต์ มันอาจอนุญาตให้เปลี่ยนรูปแบบการป้อนข้อมูลเป็นอะไรที่ปกติมากขึ้นใช้Sเพื่อรวมมากกว่าVการประเมิน แต่ฉันไม่คิดว่าจะบันทึกไบต์และฉันชอบรูปแบบที่ขี้ขลาดนี้

คำอธิบาย

Ỵµ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.

ดังนั้นแนวคิดพื้นฐานคือเรามั่นใจได้ว่ามีราชินีมากที่สุดในแต่ละ antidiagonal, diagonal และ column; และหนึ่งราชินีในแต่ละแถว เงื่อนไขเหล่านี้อยู่ด้วยกันมากพอที่จะกำหนดว่าจะต้องมีราชินีมากที่สุดในแต่ละแถวสี่สายและควีนจำนวนหนึ่งเท่ากับความยาวด้านข้างของกระดาน

อนึ่งเจลลี่อาจทำกับตัวต้าน antidiagonals ในตัว แต่ AFAICT ดูเหมือนจะไม่มีเลยดังนั้นฉันต้องตั้งสติเพื่อสะท้อนกระดานแล้วจดแนวทแยงมุม

อีกประการหนึ่งที่น่าสนใจคือทราบว่าการเปลี่ยน=1ṂไปE(เท่ากันทั้งหมด) ให้ทั่วไปn -queens ตรวจสอบซึ่งจะยอมรับn × nคณะกรรมการที่แต่ละแถวคอลัมน์เส้นทแยงมุมและ antidiagonal มีไม่เกินkราชินีและคณะกรรมการมีว่าkn queens การ จำกัดkให้เท่ากับ 1 จริง ๆ แล้วต้องเสียค่าสองไบต์

อ็อกเทฟ, 57 70 67 51 52 ไบต์

บันทึก 1 ไบต์โดยใช้flipแทนที่จะrot90ต้องขอบคุณ @LuisMendo แต่พบข้อบกพร่องในเคส 1x1

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

รับอินพุตเป็นเมทริกซ์ไบนารีที่มี 1 แทน Queen และ 0 แทนพื้นที่ว่าง

สร้างฟังก์ชั่นที่ไม่ระบุชื่อที่แรกเชื่อมเมทริกซ์การป้อนข้อมูลและการแปลง

spdiagsสร้างเมทริกซ์ที่มีจำนวนแถวเท่ากันขณะที่อาร์กิวเมนต์กับ diagonals กลายเป็นคอลัมน์ (zero-padded ตามความจำเป็น) ดังนั้น concatenate spdiagsของเมทริกซ์อินพุตเพื่อให้ได้ diagonals และspdiagsเมทริกซ์พลิกแนวนอนเพื่อรับ antidiagonals

ตอนนี้หาผลรวมของแต่ละคอลัมน์ของเมทริกซ์ที่ต่อกันแล้วและตรวจสอบให้แน่ใจว่าแต่ละคอลัมน์นั้นเท่ากับ 1

เรียกใช้ตัวอย่างในideone

MATL , 38 34 ไบต์

ปิด 4 ไบต์ด้วย@beaker !

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

อินพุตเป็นอาร์เรย์สองมิติของศูนย์และรายการโดยใช้เครื่องหมายอัฒภาคเป็นตัวคั่นแถว

สิ่งนี้จะส่งผลให้เวกเตอร์คอลัมน์ของคนที่เป็นความจริงและเวกเตอร์คอลัมน์ที่มีอย่างน้อยหนึ่งศูนย์เป็นเท็จ

ลองออนไลน์!รหัสส่วนท้ายเป็นifสาขาหนึ่งที่แสดงให้เห็นถึงความจริงหรือความเท็จ

หรือตรวจสอบกรณีทดสอบทั้งหมดตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

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 ไบต์

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

ฟังก์ชั่นรถไฟที่ไม่เปิดเผยตัวซึ่งใช้ Boolean matrix เป็นอาร์กิวเมนต์

ลองออนไลน์!

( +/ผลรวม&ของ,ravel =เท่ากับ#จำนวนแถว)

* และ (จำนวนครั้ง)

1หนึ่ง=เท่ากับสูงสุด[:>./

+/ผลรวมใน/.แนวทแยงมุม,และ (สว่างขึ้น catenated ไปที่)

+/ผลรวมใน/.แนวทแยงมุม&ของ|.การย้อนกลับ,และ

+/ผลรวมทั่ว,และ

+/ผลรวม&ของ|:การไขว้กัน

SnakeEx , 67 ไบต์

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

ใช้_แทน.การป้อนข้อมูล ส่งคืนการแข่งขัน 1 ครั้งหรือมากกว่าสำหรับความจริงการแข่งขัน 0 ครั้งสำหรับการปลอมแปลง คุณสามารถหาล่ามออนไลน์ได้ที่ลิงค์ในส่วนหัว

คำอธิบาย

SnakeEx เป็นภาษาจากที่2 มิติรูปแบบการจับคู่ความท้าทาย มันกำหนด "งู" ที่เคลื่อนไปรอบ ๆ สิ่งที่ตรงกับตาราง งูสามารถวางไข่งูชนิดอื่นได้ทำให้ภาษามีพลังมาก

ลองดูโปรแกรมนี้จากล่างขึ้นบน

n:_+$

สิ่งนี้นิยามงูnที่ตรงกับขีดล่าง 1 อันหรือมากกว่านั้นแล้วตามขอบของตาราง โปรดทราบว่าสิ่งนี้อาจอยู่ในทิศทางใดก็ได้ทั้ง 8 ทิศทาง - ทิศทางจะถูกกำหนดเมื่องูวางไข่

q:_*Q_*$

คล้ายกับnข้างต้นสิ่งนี้นิยามqว่าเป็นงูที่ตรงกับขีดล่างQใด ๆ จำนวนเดียวขีดล่างใด ๆ และขอบของตาราง กล่าวอีกนัยหนึ่งคือแถว / คอลัมน์ / แนวทแยงที่มีเพียงราชินีเดียวในนั้น

e:.$

e เป็นงูที่จับคู่ตัวละครตัวหนึ่งกับขอบของกริด

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

งูหลักm ใช้หน่วยการสร้างเหล่านี้เพื่อตรวจสอบบอร์ดทั้งหมด ตามแนวคิดแล้วมันวิ่งไปรอบ ๆ ขอบด้านนอกของตารางวางไข่งูตัวอื่น ๆ เพื่อตรวจสอบว่าคอลัมน์และแถวทั้งหมดมีราชินีหนึ่งตัวแน่ชัด หากงูตัวใดตัวหนึ่งเกิดขึ้นไม่ตรงกันการแข่งขันทั้งหมดจะล้มเหลว มาทำลายมันกันเถอะ

• ( )%{4}ดำเนินการสิ่งที่อยู่ในวงเล็บ 4 ครั้งหนึ่งครั้งสำหรับแต่ละด้าน (ในสิ่งต่อไปนี้จะเป็นประโยชน์ในการถ่ายภาพด้านใดด้านหนึ่ง - พูดว่าขอบด้านบนของตารางเริ่มจากมุมซ้ายบนและขยับไปทางขวา)
• {q<>}วางไข่qงูไปในทิศทางเดียวกันกับที่งูหลักกำลังเคลื่อนที่ สิ่งนี้จะตรวจสอบว่าขอบปัจจุบันเป็นไปตามกฎ โปรดทราบว่างูวางไข่ไม่ย้ายตัวชี้การจับคู่หลักของงูดังนั้นเราจึงยังอยู่ที่จุดเริ่มต้นของขอบ
• ( )* ตรงกับ 0 หรือมากกว่าของสิ่งที่อยู่ในวงเล็บ
• {q<R>}วางไข่qงูหันขวาจากทิศทางหลักของงู (เช่นหากงูหลักเคลื่อนไปทางขวาตามขอบด้านบนงูนี้จะเลื่อนลง) การตรวจสอบแต่ละคอลัมน์ / แถว
• [ ] จับคู่หนึ่งในตัวเลือกภายในวงเล็บเหลี่ยม:
  • {q<RF>}วางไข่qงูหันไปทางขวา 45 องศา (เช่นRight และForward) จากทิศทางหลักของงู qงูตรงกับเส้นทแยงมุมถ้ามีตรงหนึ่งราชินี
  • {n<RF>}วางไข่nงูแทน nงูตรงกับเส้นทแยงมุมถ้ามีไม่มีราชินี
• . จับคู่อักขระใด ๆ เลื่อนตัวชี้การจับคู่ไปข้างหน้า
• {e<>}หลังจากการตรวจสอบเป็นจำนวนมากและแนวนอนเส้นทแยงมุมเป็นไปได้ที่เรายืนยันว่าเราอยู่ที่ขอบโดยวางไข่
• ในที่สุด<R>เลี้ยวขวางูหลักพร้อมที่จะจับคู่กับขอบต่อไป

สิ่งแปลก ๆ

• ไม่มีสิ่งใดในโปรแกรมเพื่อให้แน่ใจว่าการจับคู่เริ่มต้นที่มุมนอก ในความเป็นจริงกรณีทดสอบความจริงให้ผลการแข่งขันหลายแห่งซึ่งบางส่วนเริ่มต้นจากด้านในที่ไหนสักแห่ง แม้จะมีสิ่งนี้ก็ตาม แต่ก็ยังไม่มีกรณีผิดพลาดใด ๆ
• ถ้าฉันอ่านภาษาสเปคขวาฉันควรจะได้รับสามารถที่จะใช้X(สาขาในทิศทางทแยงมุมทั้งหมด) RFในสถานที่ของ น่าเสียดายที่ล่ามออนไลน์กล่าวว่าเป็นข้อผิดพลาดทางไวยากรณ์ ฉันพยายาม*(สาขาทุกทิศทุกทาง) แต่นั่นก็หยุดล่าม
• ในทางทฤษฎีสิ่งที่_*Q?_*$ควรจะทำงานเพื่อจับคู่ "อย่างน้อยที่สุดหนึ่งราชินี" ในแนวทแยงมุม แต่ก็ยังแขวนล่าม ฉันเดาว่าความเป็นไปได้ของการแข่งขันว่างเปล่าทำให้เกิดปัญหา

ทับทิม 120 ไบต์

ฟังก์ชั่นแลมบ์ดาตามสเป็คดั้งเดิมที่ต้องการอินพุตเป็นสตริง

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

แปลง Q เป็นตัวเลขที่ซับซ้อนและลบออกจากกัน หากความแตกต่างระหว่างพิกัดของสองราชินีใด ๆ นั้นเป็นแนวนอนแนวตั้งหรือแนวทแยงการยกกำลังเป็นอันดับ 4 จะให้จำนวนจริงและการจัดเรียงนั้นไม่ถูกต้อง

Ungolfed ในโปรแกรมทดสอบ

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 ไบต์

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

ลองออนไลน์!

-32 ไบต์เนื่องจาก @beaker สังเกตเห็นการเปลี่ยนแปลงในข้อกำหนดคุณสมบัติอินพุต; ฉันเปลี่ยนภาษาจาก Python 3 เป็น 2 ทำให้ฉันสามารถใช้งานได้inputเพื่อป้อนข้อมูลเป็นอาร์เรย์ของสตริงหรืออาร์เรย์ของอักขระอาร์เรย์

-45 ไบต์ขอบคุณ @Leaky Nun

JavaScript (ES6), 115 ไบต์

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

Ungolfed:

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 ไบต์

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

นี่เป็นเรื่องที่แย่มากที่จะอ่านดังนั้นฉันจึงมีเวอร์ชั่นของกอล์ฟที่ต่ำกว่าเล็กน้อย

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

นี่คือรหัสเดียวกัน แต่มีการขึ้นบรรทัดใหม่เพื่อแยกสิ่งที่เกิดขึ้น

รหัสตัวเองเป็นฟังก์ชั่นแลมบ์ดานิรนามซึ่งใช้อาร์เรย์ของสตริง ( x) ในรูปแบบ["..Q", "Q..", ".Q."]ในรูปแบบ

บรรทัดแรกคือการจับคู่แต่ละสตริงกับดัชนีของอักขระ Q ในสตริงนั้น หากไม่มีอักขระ Q จะถูกแทนที่ด้วย -2 ¹ 1yนี้แถวใหม่ของดัชนีได้รับมอบหมายให้ตัวแปร

บรรทัดถัดไปซิปดัชนีอาร์เรย์นี้ด้วยตัวเองชดเชยหนึ่ง (หมุน) สิ่งนี้ส่งผลให้มีคู่ของดัชนีติดต่อกัน

บรรทัดถัดไปมีความซับซ้อนเป็นพิเศษ มันจะผ่านแต่ละคู่ของดัชนีและลบขนาดเล็กจากขนาดใหญ่ ถ้านี่คือ 1 (และเราไม่ได้อยู่ในคู่สุดท้าย² ) แสดงว่ามีควีนสองตัวที่อยู่ในแนวทแยงเดียวกันและมีการแทรกค่า -2 มิฉะนั้นดัชนีเดิมของราชินีในสตริงจะถูกแทรก .

บรรทัดสุดท้ายจะสรุปดัชนีทั้งหมดสำหรับแต่ละรายการและตรวจสอบว่าเป็นหมายเลขสามเหลี่ยมของ n-1 หรือไม่โดยที่ n คือความกว้าง (หรือความสูง) ของตาราง

1: -1 จะเป็นของฉันไป แต่เป็น 1 นอกเหนือจาก 0 ดังนั้นจะยุ่งกับการตรวจสอบของเส้นทแยงมุม ลบของมันเป็นสิ่งสำคัญที่จะทำให้ผลรวมขั้นสุดท้ายผิด ฉันคิดถึงตัวเลขสูง (ที่มีตัวเลขหลักเดียว) เช่น 9 แต่ฉันไม่สามารถแน่ใจได้ว่าจะไม่ส่งผลให้มีการยืนยันที่ไม่ถูกต้อง
2: กระดานไม่พันรอบในขณะที่rotateฟังก์ชันอาเรย์ของรูบี้ทำและถ้าคู่สุดท้ายแตกต่างกันทีละอันมันไม่สำคัญ - นั่นไม่ใช่เส้นทแยงมุม

PHP, 137 143 ไบต์

แรงบันดาลใจจากโซลูชันของ 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;

รับอินพุตจากอาร์กิวเมนต์บรรทัดคำสั่งแรก ทำงานด้วย-rทำงานด้วยต้องการตัวแบ่งบรรทัดไบต์เดียว
^{จริงๆแล้วคุณสามารถใช้ตัวละครใดก็ได้ยกเว้น0การขึ้นบรรทัดใหม่}
พิมพ์ true ( 1) หรือ false (สตริงว่าง)

ชำรุด

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 ไบต์

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

ฟังก์ชันที่ไม่ระบุชื่อรับรายการสตริงเป็นอินพุต

Python 2 , 175 ไบต์

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