Lý lịch

Hãy xem xét một giải đấu vòng tròn, trong đó mỗi thí sinh chơi một trò chơi với mọi thí sinh khác. Không có trận hòa, vì vậy mọi trò chơi đều có người chiến thắng và kẻ thua cuộc. Một thí sinh Một là vua của giải đấu, nếu cho mỗi thí sinh khác B , hoặc A đánh bại B , hoặc A đánh bại một thí sinh C người lần lượt nhịp B . Có thể thấy rằng mọi giải đấu đều có ít nhất một vị vua (mặc dù có thể có một vài). Trong thử thách này, nhiệm vụ của bạn là tìm ra các vị vua của một giải đấu nhất định.

Đầu vào và đầu ra

Đầu vào của bạn là một N × Nma trận boolean Tvà tùy chọn số lượng N ≥ 2thí sinh. Mỗi mục T[i][j]đại diện cho kết quả của trò chơi giữa các thí sinh ivà j, với giá trị 1 đại diện cho một chiến thắng ivà 0 một chiến thắng cho j. Lưu ý rằng T[i][j] == 1-T[j][i]nếu i != j. Đường chéo Tbao gồm 0s.

Đầu ra của bạn sẽ là danh sách các vị vua trong giải đấu Tđại diện, sử dụng lập chỉ mục dựa trên 0 hoặc dựa trên 1. Thứ tự của các vị vua là không liên quan, nhưng không nên có sự trùng lặp.

Cả đầu vào và đầu ra có thể được thực hiện trong bất kỳ định dạng hợp lý.

Quy tắc và tính điểm

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

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

Những trường hợp thử nghiệm sử dụng lập chỉ mục dựa trên 0. Đối với lập chỉ mục dựa trên 1, tăng từng giá trị đầu ra.

 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 byte

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

Hãy để chúng tôi tìm hiểu nếu ilà một vị vua. Sau đó cho mỗi jgiá trị T[i][j]==1 OR there is a k such that T[i][k] * T[k][l] == 1. Nhưng điều kiện thứ hai cũng có thể được thay thế bằng sum_over_k(T[i][k] * T[k][l])>0, nhưng đây chỉ là một mục nhập của ma trận T*T(nếu bạn coi Tlà một ma trận). Các ORsau đó có thể được thực hiện lại bằng cách thêm Tvào kết quả đó, vì vậy chúng tôi chỉ phải kiểm tra xem n-1giá trị của hàng icủa T*T+Tlà lớn hơn không, để xem liệu ilà vua. Đây chính xác là những gì chức năng của tôi làm.

(Đây là MATLAB, vì vậy các chỉ số đều dựa trên 1.)

Các ma trận MATLAB phải được mã hóa bằng dấu chấm phẩy dưới dạng các dấu phân cách dòng:

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

Thạch, 13 12 11 byte

a"€¹o/€oḅ1M

Đầu ra là 1 dựa. Hãy thử trực tuyến!

Ngoài ra, sử dụng toán tử bitwise thay vì thao tác mảng:

×Ḅ|/€|ḄBS€M

Một lần nữa, đầu ra là dựa trên 1. Hãy thử trực tuyến!

Lý lịch

Đối với thí sinh A , chúng ta có thể tìm thấy tất cả B mà A đánh bại C nhịp B bằng cách lấy tất cả các hàng tương ứng với một C mà C đánh bại Một . Ifr các B ^thứ entry của C ^th là 1 , ta có C đánh bại B .

Nếu chúng ta tính toán các OR logic của tất cả các mục tương ứng của các cột được chọn, chúng ta sẽ nhận được một vectơ duy nhất cho biết liệu A có đánh bại B bằng cách chuyển đổi hay không. Cuối cùng, ORing vectơ kết quả với hàng tương ứng của ma trận đầu vào cung cấp cho Booleans cho dù A đánh bại B , bằng cách chuyển đổi hoặc trực tiếp.

Lặp lại điều này cho mỗi hàng, chúng tôi đếm số lượng 1 trong mỗi vectơ, do đó tính toán số lượng thí sinh mỗi nhịp A. Số lượng tối đa tương ứng với các vị vua của giải đấu.

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

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 sử dụng numpy, 54 byte

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

Thực hiện trong một ma trận numpy, tạo ra một ma trận hàng numpy của các chỉ số dựa trên 0.

Một cách khác để nghĩ về một vị vua là một thí sinh mà tất cả các thí sinh đều ở trong liên minh của nhà vua, những người mà nhà vua đánh bại, và những người mà những người đó đánh bại. Nói cách khác, đối với mỗi thí sinh, có một con đường dài tối đa 2 từ nhà vua đến họ trong số các mối quan hệ "đánh bại".

Ma trận I + M + M*Mmã hóa số lượng đường dẫn 0, 1 hoặc 2 bước từ mỗi nguồn đến từng mục tiêu. Một người chơi là một vị vua nếu hàng của ma trận này chỉ có các mục tích cực. Vì 0 là Falsey, allcho chúng tôi biết nếu một hàng là tất cả khác không. Chúng tôi áp dụng điều này cho mỗi hàng và xuất ra các chỉ số của kết quả khác.

JavaScript (ES6), 83 byte

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 byte

Xy+HY^!Af

Đầu vào là: đầu tiên là số lượng thí sinh và trên một dòng riêng biệt một ma trận với các hàng được phân tách bằng dấu chấm phẩy. Đầu ra là 1 dựa.

Ví dụ, trường hợp thử nghiệm thứ năm có đầu vào

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

và trường hợp thử nghiệm cuối cùng có đầu vào

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]

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

Giải trình

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 byte

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

Gọi bằng cách sử dụng:

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

coi chừng vì đầu ra là 1 chỉ mục (đã lưu một vài byte không cố lọc ra 0s so với falses)