พื้นหลัง

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

อินพุตและเอาต์พุต

การป้อนข้อมูลของคุณคือN × NเมทริกบูลีนTและเลือกจำนวนN ≥ 2ผู้เข้าแข่งขัน แต่ละรายการที่T[i][j]แสดงให้เห็นถึงผลของเกมระหว่างการแข่งขันที่iและjมีค่า 1 เป็นตัวแทนของผู้ชนะสำหรับiคนและ 0 jชนะสำหรับ โปรดทราบว่าถ้าT[i][j] == 1-T[j][i] i != jเส้นทแยงมุมTประกอบด้วย 0s

ผลลัพธ์ของคุณจะเป็นรายชื่อของกษัตริย์ในทัวร์นาเมนต์ที่Tแสดงโดยใช้การจัดทำดัชนีแบบอิง 0 หรือ 1 คำสั่งของกษัตริย์ไม่เกี่ยวข้อง แต่ไม่ควรมีการซ้ำซ้อน

ทั้งอินพุทและเอาท์พุทสามารถทำได้ในรูปแบบที่สมเหตุสมผล

กฎและการให้คะแนน

คุณสามารถเขียนโปรแกรมเต็มรูปแบบหรือฟังก์ชั่น จำนวนไบต์ต่ำสุดที่ชนะและช่องโหว่มาตรฐานไม่ได้รับอนุญาต

กรณีทดสอบ

กรณีทดสอบเหล่านี้ใช้การจัดทำดัชนีแบบ 0 สำหรับการจัดทำดัชนีแบบ 1 ให้เพิ่มค่าเอาต์พุตแต่ละค่า

 2 [[0,0],[1,0]] -> [1]
 3 [[0,1,0],[0,0,0],[1,1,0]] -> [2]
 3 [[0,1,0],[0,0,1],[1,0,0]] -> [0,1,2]
 4 [[0,1,1,1],[0,0,1,0],[0,0,0,0],[0,1,1,0]] -> [0]
 4 [[0,1,1,0],[0,0,1,0],[0,0,0,1],[1,1,0,0]] -> [0,2,3]
 5 [[0,1,0,0,1],[0,0,0,0,1],[1,1,0,0,0],[1,1,1,0,1],[0,0,1,0,0]] -> [3]
 5 [[0,1,0,1,0],[0,0,1,1,1],[1,0,0,0,0],[0,0,1,0,1],[1,0,1,0,0]] -> [0,1,4]
 5 [[0,0,0,0,0],[1,0,1,1,0],[1,0,0,0,1],[1,0,1,0,1],[1,1,0,0,0]] -> [1,3,4]
 6 [[0,0,0,0,0,0],[1,0,1,1,0,0],[1,0,0,1,1,0],[1,0,0,0,1,1],[1,1,0,0,0,1],[1,1,1,0,0,0]] -> [1,2,3,4,5]
 6 [[0,0,1,1,1,0],[1,0,0,1,1,1],[0,1,0,0,1,0],[0,0,1,0,0,1],[0,0,0,1,0,1],[1,0,1,0,0,0]] -> [0,1,2,3,5]
 6 [[0,1,1,0,0,1],[0,0,0,1,0,1],[0,1,0,1,1,0],[1,0,0,0,1,1],[1,1,0,0,0,0],[0,0,1,0,1,0]] -> [0,1,2,3,4,5]
 8 [[0,0,1,1,0,1,1,1],[1,0,1,0,1,1,0,0],[0,0,0,1,1,0,0,0],[0,1,0,0,0,1,0,0],[1,0,0,1,0,1,0,0],[0,0,1,0,0,0,1,0],[0,1,1,1,1,0,0,1],[0,1,1,1,1,1,0,0]] -> [0,1,4,6,7]
20 [[0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1],[1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1],[0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1],[0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1],[1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1,1,0,1],[0,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1],[0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0],[1,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,1,1,1,0],[1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1],[1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,1],[1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,0,0,0],[0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1],[0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1],[1,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1],[0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1],[0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1],[0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1],[0,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,1],[1,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0]] -> [0,1,3,4,5,7,8,11,15,17,18]

Matlab, 36 35 29 ไบต์

@(T,N)find(sum(T*T>-T,2)>N-2)

ให้เราดูว่าiเป็นราชาหรือเปล่า จากนั้นแต่ละค่าj T[i][j]==1 OR there is a k such that T[i][k] * T[k][l] == 1แต่เงื่อนไขที่สองสามารถถูกแทนที่ด้วยsum_over_k(T[i][k] * T[k][l])>0แต่นี่เป็นเพียงรายการของเมทริกซ์T*T(ถ้าคุณพิจารณาTว่าเป็นเมทริกซ์) ORนั้นจะสามารถเล่นซ้ำได้โดยการเพิ่มTผลการค้นหานั้นดังนั้นเราก็ต้องตรวจสอบว่าn-1ค่าของแถวiของT*T+Tมีค่ามากกว่าศูนย์เพื่อดูว่าiเป็นกษัตริย์ นี่คือสิ่งที่ฟังก์ชั่นของฉันทำ

(นี่คือ MATLAB ดังนั้นดัชนีจึงใช้ 1)

เมทริกซ์ MATLAB ควรเข้ารหัสด้วยเครื่องหมายอัฒภาคเป็นตัวคั่นบรรทัด:

[[0,0,0,0,0];[1,0,1,1,0];[1,0,0,0,1];[1,0,1,0,1];[1,1,0,0,0]] 

เยลลี่, 13 12 11 ไบต์

a"€¹o/€oḅ1M

ผลลัพธ์เป็นแบบ 1 ลองออนไลน์!

อีกทางเลือกหนึ่งโดยใช้ตัวดำเนินการระดับบิตแทนการจัดการอาร์เรย์

×Ḅ|/€|ḄBS€M

อีกครั้งเอาต์พุตเป็นแบบ 1 ลองออนไลน์!

พื้นหลัง

สำหรับผู้เข้าประกวดเราสามารถหาทั้งหมดBดังกล่าวที่ตี C ชนะ Bโดยการทุกแถวที่สอดคล้องกับCเช่นที่C ชนะ IFR B ^THรายการของC ^THคือ1เรามีที่C จังหวะ B

หากเราคำนวณ ORs แบบลอจิคัลของรายการที่เกี่ยวข้องทั้งหมดของคอลัมน์ที่เลือกเราจะได้เวกเตอร์เดี่ยวที่ระบุว่าA ชนะ Bตามความไวหรือไม่ ในที่สุด ORing เวกเตอร์ที่ได้ด้วยแถวที่สอดคล้องกันของเมทริกซ์อินพุทจะทำให้บูลีนไม่ว่าจะเป็น A Beat Bไม่ว่าจะด้วยทรานซิสชันหรือโดยตรง

ทำซ้ำเช่นนี้สำหรับทุกแถวเรานับจำนวนของ1 's ในแต่ละเวกเตอร์ดังนั้นการคำนวณปริมาณของผู้เข้าแข่งขันแต่ละจังหวะ จำนวนมากที่สุดสอดคล้องกับราชาของทัวร์นาเมนต์

มันทำงานอย่างไร

a"€¹o/€oḅ1M  Main link. Argument: M (matrix)

   ¹         Yield M.
  €          For each row of M:
a"           Take the logical AND of each entry of that row and the corr. row of M.
    o/€      Reduce each resulting matrix by logical OR.
       o     Take the logical OR of the entries of the resulting maxtrix and the
             corr. entries of M.
        ḅ1   Convert each row from base 1 to integer, i.e. sum its elements.
          M  Get all indices of maximal sums.

×Ḅ|/€|ḄBS€M  Main link. Argument: M (matrix)

 Ḅ           Convert each row of M from base 2 to integer. Result: R
×            Multiply the entries of each column of M by the corr. integer.
  |/€        Reduce each row fo the resulting matrix by bitwise OR.
     |Ḅ      Bitwise OR the results with R.
       BS€   Convert to binary and reduce by sum.
             This counts the number of set bits for each integer.
          M  Get all indices of maximal popcounts.

Python ใช้จำนวน 54 ไบต์

import numpy
lambda M:(M**0+M+M*M).all(1).nonzero()[0]

รับเมทริกซ์ numpy ส่งออก matrix numpy row ของดัชนีที่อิง 0

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

เมทริกซ์I + M + M*Mเข้ารหัสจำนวนเส้นทางของ 0, 1 หรือ 2 ขั้นตอนจากแต่ละแหล่งไปยังแต่ละเป้าหมาย ผู้เล่นเป็นราชาถ้าแถวของเมทริกซ์นี้มีรายการเชิงบวกเท่านั้น ตั้งแต่ 0 คือ Falsey allบอกเราว่าแถวเป็นศูนย์ทั้งหมดหรือไม่ เราใช้สิ่งนี้กับแต่ละแถวและส่งออกดัชนีของผลลัพธ์ที่ไม่ใช่ศูนย์

JavaScript (ES6), 83 ไบต์

a=>a.map((b,i)=>b.every((c,j)=>c|i==j|b.some((d,k)=>d&a[k][j]))&&r.push(i),r=[])&&r

MATL , 12 10 9 ไบต์

Xy+HY^!Af

อินพุตคือ: จำนวนของผู้เข้าแข่งขันก่อนและในแต่ละบรรทัดจะมีเมทริกซ์ที่มีแถวคั่นด้วยเครื่องหมายอัฒภาค ผลลัพธ์เป็นแบบ 1

ตัวอย่างเช่นกรณีทดสอบที่ห้ามีอินพุต

4
[0,1,1,0; 0,0,1,0; 0,0,0,1; 1,1,0,0]

และกรณีทดสอบสุดท้ายมีอินพุต

20
[0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1; 1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1; 0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1; 0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1; 1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1,1,0,1; 0,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1; 0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0; 1,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,1,1,1,0; 1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1; 1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,1; 1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,0,0,0; 0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1; 0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1; 1,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1; 0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1; 0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1; 0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1; 0,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,1; 1,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0; 0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0]

ลองออนไลน์!

คำอธิบาย

Xy    % Implicitly take input: number. Push identity matrix with that size
+     % Implicitly take input: matrix. Add to identity matrix
HY^   % Matrix square
!     % Transpose
A     % Row vector with true entries for columns that contain all nonzero values
f     % Indices of nonzero values

Javascript 136 131 121 112 112 ไบต์

(n,m)=>m.map((a,k)=>eval(a.map((o,i)=>o||eval(a.map((p,j)=>p&&m[j][i]).join`|`)).join`+`)>n-2&&k+1).filter(a=>a)

โทรโดยใช้:

f=(n,m)=>m.map((a,k)=>eval(a.map((o,i)=>o||eval(a.map((p,j)=>p&&m[j][i]).join`|`)).join`+`)>n-2&&k+1).filter(a=>a)

f(20,[[0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1],
     [1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1],
     [0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1],         
     [0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1],
     [1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1,1,0,1],         
     [0,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1],
     [0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0],         
     [1,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,1,1,1,0],
     [1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1],         
     [1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,1],
     [1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,0,0,0],         
     [0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1],
     [0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1],         
     [1,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1],
     [0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1],         
     [0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1],
     [0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1],         
     [0,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,1],
     [1,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0],             
     [0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0]])

ข้อระวังเนื่องจากเอาต์พุตถูกทำดัชนี 1 รายการ (บันทึกไว้สองสามไบต์ที่ไม่ได้พยายามกรอง 0 วินาทีเทียบกับเท็จ)