Arka fon

Her yarışmacının diğer yarışmacılara karşı bir oyun oynadığı yuvarlak robin turnuvasını düşünün. Beraberlik yok, bu yüzden her oyunda bir kazanan ve kaybeden var. Bir yarışmacı A bir olan kral her yarışmacı için ise, turnuvanın B ya A yendi B veya A başka yarışmacı yendi C sırayla yendi B . Her turnuvanın en az bir kralı olduğu gösterilebilir (ancak birkaç tane olabilir). Bu mücadelede, göreviniz verilen bir turnuvanın krallarını bulmaktır.

Giriş ve çıkış

N × NGirişiniz bir boole matrisi Tve isteğe bağlı N ≥ 2olarak yarışmacı sayısıdır . Her giriş T[i][j]rakip arasından oyunun sonucunu temsil etmektedir ive jdeğeri 1 için kazanmak temsil eder, ibir kazanmak ve 0 j. Dikkat T[i][j] == 1-T[j][i]edin i != j. Diyagonal T0'lardan oluşur.

Çıktınız, T0 veya 1 tabanlı indeksleme kullanarak turnuvadaki kralların listesi olacaktır . Kralların sırası ilgisizdir, ancak kopyalar olmamalıdır.

Hem giriş hem de çıkış makul bir formatta alınabilir.

Kurallar ve puanlama

Tam bir program veya işlev yazabilirsiniz. En düşük bayt sayısı kazanır ve standart boşluklara izin verilmez.

Test senaryoları

Bu test senaryoları 0 tabanlı indeksleme kullanır. 1 tabanlı indeksleme için, her çıkış değerini artırın.

 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 bayt

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

iKral olup olmadığını öğrenelim . Sonra her biri jiçin değer T[i][j]==1 OR there is a k such that T[i][k] * T[k][l] == 1. Ancak ikinci koşul da değiştirilebilir sum_over_k(T[i][k] * T[k][l])>0, ancak bu sadece matrisin bir girdisidir T*T( Tbir matris olarak düşünüyorsanız ). ORSonra eklenerek yeniden gönderilebilir Teğer biz sadece kontrol etmek zorunda böylece, o sonuca n-1sıranın değerleri iarasında T*T+Tsıfırdan büyük olup olmadığını görmek için, ikraldır. Bu benim fonksiyonumun yaptığı şey.

(Bu MATLAB, endeksler 1 tabanlıdır.)

MATLAB matrisleri, çizgi sınırlayıcılar olarak noktalı virgülle kodlanmalıdır:

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

Jöle, 13 12 11 bayt

a"€¹o/€oḅ1M

Çıktı 1 tabanlıdır. Çevrimiçi deneyin!

Alternatif olarak, dizi işleme yerine bitsel işleçleri kullanma:

×Ḅ|/€|ḄBS€M

Yine, çıktı 1 tabanlıdır. Çevrimiçi deneyin!

Arka fon

Yarışmacı için A , hepimiz bulabilirsiniz B öyle ki A C yendi B beat bir uygun tüm satırları alarak C öyle ki C A yendi . İfr B ^inci giriş C ^inci olduğunu 1 , biz buna sahip C B yendi .

Seçilen sütunların karşılık gelen tüm girişlerinin mantıksal OR'lerini hesaplarsak, A'nın B'yi geçişli olup olmadığını gösteren tek bir vektör elde ederiz . Son olarak, ortaya çıkan vektörün giriş matrisinin karşılık gelen sırası ile ORinglenmesi, Booleans'e A çarpımı B'yi transisitede veya doğrudan olarak verir.

Bunu her satır için tekrarlayarak , her vektördeki 1 sayısını sayarız , dolayısıyla her A'nın attığı yarışmacıların miktarını hesaplarız . Maksimum sayılar turnuvanın krallarına karşılık gelir.

Nasıl çalışır

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 kullanarak numpy, 54 bayt

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

Numpy matrisini alır, 0 tabanlı indekslerin numpy satır matrisini verir.

Bir kralı düşünmenin bir başka yolu, tüm yarışmacıların kralın birliği, kralın dövdüğü insanlar ve bu insanların dövdüğü insanlar olduğu bir yarışmacıdır. Diğer bir deyişle, her yarışmacı için, “dövüş” ilişkisi arasında kraldan onlara en fazla 2 uzunluk yolu vardır.

Matris I + M + M*M, her kaynaktan her hedefe 0, 1 veya 2 adımlık yol sayısını kodlar. Bu matrisin sıralarında sadece olumlu girişler varsa oyuncu kraldır. 0 Falsey olduğundan, allbir satırın sıfırdan farklı olup olmadığını söyler. Bunu her satıra uygularız ve sıfır olmayan sonuçların indekslerini çıkarırız.

JavaScript (ES6), 83 bayt

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 bayt

Xy+HY^!Af

Girdi: önce yarışmacıların sayısı ve ayrı bir satırda noktalı virgülle ayrılmış satırları olan bir matris. Çıktı 1 tabanlıdır.

Örneğin, beşinci test senaryosunun girişi vardır

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

ve son test senaryosunun girişi var

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]

Çevrimiçi deneyin!

açıklama

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 bayt

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

Şunu kullanarak ara:

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

watchout, çünkü çıkış 1-endeksli (hatalar ve hatalar 0s filtrelemeye çalışılmadan birkaç bayt kaydedildi)