トーナメントの王は誰ですか？

13

バックグラウンド

ラウンドロビントーナメントを考えてみましょう。各トーナメントでは、各競技者が他のすべての競技者に対して1つのゲームをプレイします。引き分けがないので、すべてのゲームには勝者と敗者がいます。競技者Aは、ある王他のすべての競技者のためならば、トーナメントのB、どちらかのAはビートBを、またはAは別の競技者破っC順番にビートBを。すべてのトーナメントには少なくとも1人のキングがいることを示すことができます（ただし、複数のトーナメントがある場合もあります）。このチャレンジでは、あなたの仕事は、与えられたトーナメントの王を見つけることです。

入出力

入力はN × Nブール行列Tであり、オプションN ≥ 2で参加者の数です。各エントリT[i][j]は、競技者iとの間のゲームの結果を表し、j値1は勝者を表し、i0は勝者を表しjます。なおT[i][j] == 1-T[j][i]場合i != j。の対角線はT0 で構成されます。

出力は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]
code-golf  array-manipulation 
— ズガルブ
ソース
（実行時間やメモリの制限はありますか？）仕様を完全に誤解しました。
— デニス
@Dennis Nope。時間とメモリが無制限の場合、プログラムが理論的に機能する限り、問題ありません。
— ズガルブ
明確にするために：T [a] [b]はT [b] [a]と同じ一致ですが、反対の角度から見たため、T [a] [b] ==！T [b] [a]
— edc65
@ edc65それは良い観察です。チャレンジに編集しました。
— -Zgarb

回答:

9

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。ただし、2番目の条件はに置き換えることもできます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]]
— フレア
ソース
おそらく、入力として出場者の数を取って、代わりにやって数バイトを保存することができますsize(T,1)
— ルイスMendoを
7

ゼリー、13 12 11バイト

a"€¹o/€oḅ1M

出力は1ベースです。オンラインでお試しください！

または、配列操作の代わりにビット演算子を使用します。

×Ḅ|/€|ḄBS€M

繰り返しますが、出力は1ベースです。オンラインでお試しください！

バックグラウンド

競技者Aの場合、CがAを打つようなCに対応するすべての行を取得することにより、AがCを打つようなすべてのBを見つけることができます。C 番目のB 番目のエントリが1の場合、CがBに勝っています。

選択した列の対応するすべてのエントリの論理和を計算すると、推移性によってAがBに勝るかどうかを示す単一のベクトルが得られます。最後に、結果のベクトルを入力行列の対応する行とOR演算すると、AがBであるかどうかを推移性によってまたは直接にブール値が得られます。

行ごとにこれを繰り返し、各ベクトルの1の数をカウントします。したがって、Aビートごとに競技者の数を計算します。最大カウントはトーナメントのキングに対応します。

使い方

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.
— デニス
ソース
1
人々はこれらを投稿し続け、x「バイト」と言っていますが、「ḅ」は実際には標準的なエンコーディングで1バイトでエンコードされていますか？申し訳ありませんが、これらの超凝縮されたスタックベースの言語は、考えられるすべての機能をユニコード文字に割り当てるだけで不正行為のように感じられるため、まったく面白くないと思います。
— -MattPutnam
2
@MattPutnam Jellyは独自のカスタムエンコーディングを使用します。（また、それは、スタックベースではない）
— spaghetto
2
@MattPutnam似たような感情がありましたが、従来のゴルフにまったく影響しません。これらが存在するという理由だけで、従来の言語を軽視する人はいません。他のSEサイトとは異なり、これには「この答えは明らかにその答えよりも明白です」というものがありません。また、技術的には禁止されていませんが、質問をサポートするために言語を変更することはありません（実際、将来の質問に対する便利なショートカットを実現し、それを操作にすることができます）。
— corsiKa
これらのアルゴリズムがキングを出力するのはなぜですか？
— -xnor
@Dennis私は今、基本的に論理またはビット演算を介して行われるブール行列乗算を参照してください。実際の行列乗算は短くなりませんか？
— -xnor
2

numpyを使用したPython、54バイト

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

numpy行列を受け取り、0ベースのインデックスのnumpy行行列を出力します。

王を考えるもう一つの方法は、すべての競技者が王の連合、王がbeatる人々、およびそれらの人々がbeatる人々である競技者としてです。言い換えれば、すべての競技者には、「ビート」関係の中で、王から彼らまでの長さが最大2のパスがあります。

マトリックスI + M + M*Mは、各ソースから各ターゲットへの0、1、または2ステップのパス数をエンコードします。この行列の行に正のエントリしかない場合、プレーヤーは王です。0はFalseyであるためall、行がすべてゼロ以外であるかどうかを示します。これを各行に適用し、非ゼロの結果のインデックスを出力します。

— xnor
ソース
私のアプローチとまったく同じように見えますが、
— 異なる
2

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
— ニール
ソース
a => a.map（（b、i）=> b.every（（c、j）=> c | i == j | b.some（（d、k）=> d＆a [ k]は[J]））&& i + 1）の.filter（A => A）が、それはあなたが出力1インデックス深刻残念であるしなければならないことを意味
— チャーリー・ウィン
2

MATL、12 10 9バイト

Xy+HY^!Af

入力は、まず競技者の数、そして別の行にセミコロンで区切られた行を持つ行列です。出力は1ベースです。

たとえば、5番目のテストケースには入力があります

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
— ルイス・メンドー
ソース
1
MATL <ジェリー\ m /
— flawr
1

ジャバスクリプト136 131 121 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インデックスであるため、監視します（0sとfalseを除外しないように数バイトを節約します）

— チャーリー・ウィン
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.