トーナメントブラケット配置アルゴリズム
対戦相手のシード（たとえば、シード1から16）のリストを前提として、そのラウンドで最上位のシードが最下位のシードを再生し、2番目のシードが2番目に下位のシードを再生するようなアルゴリズムを作成しようとしています。
1と16、2と15などを「一致」にグループ化するのはかなり簡単ですが、次のラウンドで高いシードが低いシードを再生することも確認する必要があります。
正しい配置のブラケットの例：
1対16 1対8 8対9 1対4 4対13 4対5 5対12 1 vs 2 2 vs 15 2 vs 7 7 vs 10 2 vs 3 3 vs 14 3 vs 6 6 vs 11
ご覧のとおり、シード1とシード2は決勝でのみ出会う。
私は次のアルゴリズムを思いついた。それは超効率的ではないかもしれませんが、私はそれが本当に必要であるとは思いません。それはPHPで書かれています。
<?php
$players = range(1, 32);
$count = count($players);
$numberOfRounds = log($count / 2, 2);
// Order players.
for ($i = 0; $i < $numberOfRounds; $i++) {
$out = array();
$splice = pow(2, $i);
while (count($players) > 0) {
$out = array_merge($out, array_splice($players, 0, $splice));
$out = array_merge($out, array_splice($players, -$splice));
}
$players = $out;
}
// Print match list.
for ($i = 0; $i < $count; $i++) {
printf('%s vs %s<br />%s', $players[$i], $players[++$i], PHP_EOL);
}
?>
このJavaScriptは、各偶数インデックスが次の奇数インデックスを再生する配列を返します
function seeding(numPlayers){
var rounds = Math.log(numPlayers)/Math.log(2)-1;
var pls = [1,2];
for(var i=0;i<rounds;i++){
pls = nextLayer(pls);
}
return pls;
function nextLayer(pls){
var out=[];
var length = pls.length*2+1;
pls.forEach(function(d){
out.Push(d);
out.Push(length-d);
});
return out;
}
}
> seeding(2)
[1, 2]
> seeding(4)
[1, 4, 2, 3]
> seeding(8)
[1, 8, 4, 5, 2, 7, 3, 6]
> seeding(16)
[1, 16, 8, 9, 4, 13, 5, 12, 2, 15, 7, 10, 3, 14, 6, 11]
仮定では、プレーヤー1と2が決勝でプレーし、プレーヤー1〜4が準決勝でプレーし、プレーヤー1〜8が準決勝でプレーするというように、AakashMが提案したように、トーナメントを決勝から再帰的に逆方向に構築できます。トーナメントは、根が最終的な木と考えてください。
ルートノードでは、プレーヤーは{1、2}です。
ツリーを再帰的に次のレベルに拡張するには、ツリーの最下層にあるすべてのノードを1つずつ取得し、それぞれに2つの子を作成し、元のノードのプレーヤーの1つを子のそれぞれに配置します。作成されたノード。次に、プレーヤーの次のレイヤーを追加してゲームにマップし、新しく追加された最悪のプレーヤーが既存の最高のプレーヤーと対戦するようにします。
ここにアルゴリズムの最初のラウンドがあります：
{1,2} --- create next layer
{1, _}
/ --- now fill the empty slots
{1,2}
\{2, _}
{1, 4} --- the slots filled in reverse order
/
{1,2}
\{2, 3} --- create next layer again
/{1, _}
{1, 4}
/ \{4, _}
{1,2} --- again fill
\ /{2, _}
{2, 3}
\{3, _}
/{1, 8}
{1, 4}
/ \{4, 5} --- ... and so on
{1,2}
\ /{2, 7}
{2, 3}
\{3, 6}
ご覧のとおり、投稿したものと同じツリーが生成されます。
PHPで書かれたソリューションも書きました。 Patrik Bodinの答えを見ましたが、もっと簡単な方法があるに違いないと思いました。
Darkangelが要求したことを実行します：すべてのシードを正しい位置に返します。試合は彼の例と同じですが、prettierの順序で、シード1とシード番号16がスキーマの外側にあります（テニストーナメントで見られるように）。
混乱がない場合（つまり、シード数の多いプレーヤーがシード数の少ないプレーヤーから常に勝つことを意味します）、決勝ではシード1とシード2の結果になります。
実際には、さらに2つのことを行います。
それは正しい順序を示しています（これは、バイを正しい位置に置くための要件です）
正しい位置にバイを埋めます（必要な場合）
単一の除去ブラケットがどのように見えるべきかについての完全な説明： http://blog.playdriven.com/2011/articles/the-not-so-simple-single-elimination-advantage-seeding/
16人の参加者のコード例：
<?php
define('NUMBER_OF_PARTICIPANTS', 16);
$participants = range(1,NUMBER_OF_PARTICIPANTS);
$bracket = getBracket($participants);
var_dump($bracket);
function getBracket($participants)
{
$participantsCount = count($participants);
$rounds = ceil(log($participantsCount)/log(2));
$bracketSize = pow(2, $rounds);
$requiredByes = $bracketSize - $participantsCount;
echo sprintf('Number of participants: %d<br/>%s', $participantsCount, PHP_EOL);
echo sprintf('Number of rounds: %d<br/>%s', $rounds, PHP_EOL);
echo sprintf('Bracket size: %d<br/>%s', $bracketSize, PHP_EOL);
echo sprintf('Required number of byes: %d<br/>%s', $requiredByes, PHP_EOL);
if($participantsCount < 2)
{
return array();
}
$matches = array(array(1,2));
for($round=1; $round < $rounds; $round++)
{
$roundMatches = array();
$sum = pow(2, $round + 1) + 1;
foreach($matches as $match)
{
$home = changeIntoBye($match[0], $participantsCount);
$away = changeIntoBye($sum - $match[0], $participantsCount);
$roundMatches[] = array($home, $away);
$home = changeIntoBye($sum - $match[1], $participantsCount);
$away = changeIntoBye($match[1], $participantsCount);
$roundMatches[] = array($home, $away);
}
$matches = $roundMatches;
}
return $matches;
}
function changeIntoBye($seed, $participantsCount)
{
//return $seed <= $participantsCount ? $seed : sprintf('%d (= bye)', $seed);
return $seed <= $participantsCount ? $seed : null;
}
?>
出力：
Number of participants: 16
Number of rounds: 4
Bracket size: 16
Required number of byes: 0
C:\projects\draw\draw.php:7:
array (size=8)
0 =>
array (size=2)
0 => int 1
1 => int 16
1 =>
array (size=2)
0 => int 9
1 => int 8
2 =>
array (size=2)
0 => int 5
1 => int 12
3 =>
array (size=2)
0 => int 13
1 => int 4
4 =>
array (size=2)
0 => int 3
1 => int 14
5 =>
array (size=2)
0 => int 11
1 => int 6
6 =>
array (size=2)
0 => int 7
1 => int 10
7 =>
array (size=2)
0 => int 15
1 => int 2
16を6に変更すると、次のようになります。
Number of participants: 6
Number of rounds: 3
Bracket size: 8
Required number of byes: 2
C:\projects\draw\draw.php:7:
array (size=4)
0 =>
array (size=2)
0 => int 1
1 => null
1 =>
array (size=2)
0 => int 5
1 => int 4
2 =>
array (size=2)
0 => int 3
1 => int 6
3 =>
array (size=2)
0 => null
1 => int 2
# Here's one in python - it uses nested list comprehension to be succinct:
from math import log, ceil
def seed( n ):
""" returns list of n in standard tournament seed order
Note that n need not be a power of 2 - 'byes' are returned as zero
"""
ol = [1]
for i in range( ceil( log(n) / log(2) ) ):
l = 2*len(ol) + 1
ol = [e if e <= n else 0 for s in [[el, l-el] for el in ol] for e in s]
return ol
私はPHP/Laravel予備のラウンドロビンあり/なしでブラケットを生成するプラグインに取り組みました。多分それはあなたに役立つかもしれません、私は何を知りません使用している技術。これがgithubです。
https://github.com/xoco70/kendo-tournaments
それが役に立てば幸い！
これは主題を検索するときに発生し、問題を解決し、シードを「よりきれいな」順序にする別の答えを見つけるのは絶望的であるため、PHPコードのバージョンを追加しますdarkangelから。高シードプレイヤーに別れを告げる可能性も追加しました。
これはOO環境でコーディングされたため、参加者の数は$ this-> finalistsにあり、バイの数は$ this-> byesにあります。バイなしでコードをテストしただけです。そして2つのさようなら。
public function getBracket() {
$players = range(1, $this->finalists);
for ($i = 0; $i < log($this->finalists / 2, 2); $i++) {
$out = array();
$reverse = false;
foreach ($players as $player) {
$splice = pow(2, $i);
if ($reverse) {
$out = array_merge($out, array_splice($players, -$splice));
$out = array_merge($out, array_splice($players, 0, $splice));
$reverse = false;
} else {
$out = array_merge($out, array_splice($players, 0, $splice));
$out = array_merge($out, array_splice($players, -$splice));
$reverse = true;
}
}
$players = $out;
}
if ($this->byes) {
for ($i = 0; $i < $this->byes; $i++ ) {
for ($j = (($this->finalists / pow(2, $i)) - 1); $j > 0; $j--) {
$newPlace = ($this->finalists / pow(2, $i)) - 1;
if ($players[$j] > ($this->finalists / (pow(2 ,($i + 1))))) {
$player = $players[$j];
unset($players[$j]);
array_splice($players, $newPlace, 0, $player);
}
}
}
for ($i = 0; $i < $this->finalists / (pow(2, $this->byes)); $i++ ) {
$swap[] = $players[$i];
}
for ($i = 0; $i < $this->finalists /(pow(2, $this->byes)); $i++ ) {
$players[$i] = $swap[count($swap) - 1 - $i];
}
return array_reverse($players);
}
return $players;
}
Cバージョン。
int * pctournamentSeedArray(int PlayerCnt)
{
int * Array;
int * PrevArray;
int i;
Array = meAlloc(sizeof(int) * PlayerCnt);
if (PlayerCnt == 2)
{
Array[0] = 0;
Array[1] = 1;
return Array;
}
PrevArray = pctournamentSeedArray(PlayerCnt / 2);
for (i = 0; i < PlayerCnt;i += 2)
{
Array[i] = PrevArray[i / 2];
Array[i + 1] = (PlayerCnt - 1) - Array[i] ;
}
meFree(PrevArray);
return Array;
}
JavaScriptコードの場合、以下の2つの関数のいずれかを使用します。前者は命令型のスタイルを具体化しており、はるかに高速です。後者は再帰的できれいですが、比較的少数のチーム（<16384）にのみ適用できます。
// imperative style
function foo(n) {
const arr = new Array(n)
arr[0] = 0
for (let i = n >> 1, m = 1; i >= 1; i >>= 1, m = (m << 1) + 1) {
for (let j = n - i; j > 0; j -= i) {
arr[j] = m - arr[j -= i]
}
}
return arr
}
ここでは、すでに占有されているスポットをミラーリングして、スポットを1つずつ埋めます。たとえば、最初にシードされたチーム（つまり、番号0）が最上位に移動します。 2番目のもの（1）は、ブラケットの残りの半分の反対側の場所を占めます。 3番目のチーム（2）は、ブラケットの半分に1をミラーリングします。ネストされたループにもかかわらず、アルゴリズムはチームの数に応じて線形の時間計算量を持ちます。
再帰的な方法は次のとおりです。
// functional style
const foo = n =>
n === 1 ? [0] : foo(n >> 1).reduce((p, c) => [...p, c, n - c - 1], [])
基本的に、前の関数と同じミラーリングを実行しますが、再帰的に実行します。
n = 1チームの場合、それは[0]だけです。n = 2チームの場合、この関数を引数n-1（つまり、1）に適用し、[0]を取得します。次に、ミラーリングされた要素を偶数の位置でそれらの間に挿入することにより、配列を2倍にします。したがって、[0]は[0, 1]になります。n = 4チームの場合、同じ操作を行うため、[0, 1]は[0, 3, 1, 2]になります。
人間が読める形式の出力を取得する場合は、結果の配列の各要素を1つずつ増やします。
const readableArr = arr.map(i => i + 1)
- 各ラウンドで、シード基準によってチームを並べ替えます
- （ラウンドにnチームがある場合）i番目の位置のチームはチームn-i +1でプレーします