在一個知名企業(yè)贊助的足球聯(lián)賽中，有256支球隊參賽。為了確保比賽的順利進行，企業(yè)指派了小悅負責熬夜加班制定每一個球隊的賽程。盡管她對足球的了解并不多，但是她對待工作的認真態(tài)度卻讓人欽佩。

在小悅的努力下，她順利完成了第一輪、第二輪和第三輪的比賽安排。然而，在大賽開始前的模擬比賽中，她發(fā)現(xiàn)了一個嚴重的問題：由于參賽球隊過多，人為的安排總會導致一些參賽球隊被遺漏了比賽。這讓她十分焦慮，因為如果不能盡快解決這個問題，聯(lián)賽的公平性和競爭性將受到嚴重影響。

為了解決這個問題，小悅開始了她的電話咨詢之旅。她先是聯(lián)系了賽事主辦方，了解參賽球隊的具體情況。隨后，她又聯(lián)系了計算機專家，希望找到一個解決辦法，確保每個參賽球隊都能順利比賽。

在與計算機專家溝通的過程中，小悅了解到這個問題并不簡單，因為要考慮到的因素非常多。不過，在專家的幫助下，她逐漸找到了問題的根源，并聽取專家的意見采取了一些有效的措施來解決它。最終，經(jīng)過小悅的不懈努力和計算機專家的協(xié)助，每個參賽球隊的賽程都被安排得合理而公正。

小悅在熬夜加班制定賽程時，扎著馬尾辮，聚精會神地盯著電腦屏幕，手指在鍵盤上飛快地敲擊著。她的眼神中閃爍著智慧的光芒，仿佛在告訴人們：她有能力解決任何問題。當她下意識挽起頭發(fā)時，這個簡單的動作，展現(xiàn)了她的優(yōu)雅和美麗。

在這個過程中，小悅學到了很多關于足球和賽程安排的知識。她也深刻體會到團隊合作的重要性，學會了如何與同事合作解決問題。最終，她的努力得到了上司和公司的肯定，也為她帶來了不少寶貴的經(jīng)驗。

小悅面臨的問題如下：錦標賽由256支隊伍組成。這是一場循環(huán)賽（全部比賽），所以有255輪，每支球隊每輪比賽一次。每支球隊在錦標賽中與其他球隊對抗一次（每場比賽在錦標賽中不會重復）。

 她的任務是實現(xiàn)一個函數(shù)buildMatchesTable，它接收團隊的數(shù)量（總是正數(shù)和偶數(shù)）并返回一個矩陣。

 矩陣中的每一行代表一輪。矩陣的每一列表示一個匹配。這場比賽是由兩支隊伍組成的一個陣列。每個團隊都用一個數(shù)字表示，從1開始直到團隊數(shù)量。

 示例(假設4只球隊參賽)： 構(gòu)建匹配表（4）

應該返回一個元組矩陣，如下所示：

{
new[]｛（1,2），（3,4）｝，//第一輪：1對2，3對4
new[]｛（1,3），（2,4）｝，//第二輪：1對3，2對4
new[]{（1,4），（2,3）}//第三輪：1對4，2對3
}

算法實現(xiàn)：

public static (int, int)[][] BuildMatchesTable(int n)
{
var matches = new (int, int)[n - 1][];  // 創(chuàng)建一個二維數(shù)組，表示比賽表
var teams = FairCycle(n).GetEnumerator();  // 獲取一個循環(huán)迭代器，用于生成比賽對陣
for (int i = 0; i < n - 1; i++)
{
var round = new (int, int)[n / 2];  // 創(chuàng)建一個一維數(shù)組，表示當前輪次的比賽對陣
for (int t = 0; t < n / 2; t++)
{
teams.MoveNext();  // 迭代到下一個比賽對陣
round[t] = teams.Current;  // 將當前比賽對陣添加到當前輪次的比賽表中
}
matches[i] = round;  // 將當前輪次的比賽表添加到總的比賽表中
// FairCycle函數(shù)會在這里負責循環(huán)到下一個比賽對陣
}
return matches;  // 返回生成的比賽表
}
static IEnumerable<(int,int)> FairCycle(int n)
{
// 將數(shù)字1到n-1按順時針方式排列
// 從12點鐘方向開始，1位于12點鐘位置
int p = 1;
while (true)
{
// 返回n和12點鐘位置的數(shù)字
yield return (p, n);
// 然后返回12點鐘左右兩側(cè)的數(shù)字配對
// 例如，11和1點鐘，10和2點鐘，以此類推
for (int i = 1; i < n / 2; i++)
{
int l = p + i;
l = l > (n - 1) ? l - (n - 1) : l;  // 對n進行循環(huán)，但不包括n本身
int r = p + (n - 1) - i;
r = r > (n - 1) ? r - (n - 1) : r;
yield return (l, r);
}
// 將時鐘旋轉(zhuǎn)n/2，使得p + n/2現(xiàn)在位于12點鐘位置
p += n / 2;
p = p > (n - 1) ? p - (n - 1) : p;
// 這將開始下一輪的配對
}
}

這段代碼實現(xiàn)了一個生成比賽表的函數(shù)`BuildMatchesTable`和一個輔助函數(shù)`FairCycle`。

`BuildMatchesTable`函數(shù)接收一個正數(shù)n作為參數(shù)，返回一個二維數(shù)組，表示比賽表。

`FairCycle`函數(shù)是一個模擬時鐘循環(huán)迭代器，用于生成球隊比賽對陣表。

讓我們以`BuildMatchesTable(4)`為例來詳細介紹`yield return`的運行過程和直接使用`return`的運行過程：

首先，我們調(diào)用`BuildMatchesTable(4)`函數(shù)，它將生成一個4個參與者的比賽表。

執(zhí)行`var teams = FairCycle(n).GetEnumerator();`時會調(diào)用`FairCycle(n)`方法，并開始執(zhí)行其中的代碼。在`FairCycle(n)`方法中，第一次調(diào)用`yield return`語句會返回一個`IEnumerator`對象，該對象用于迭代生成比賽對陣。

這意味著在執(zhí)行`var teams = FairCycle(n).GetEnumerator();`之后，`teams`變量將持有一個可以用于迭代生成比賽對陣的迭代器對象。你可以使用`teams.MoveNext()`方法來逐個獲取比賽對陣，每次調(diào)用`MoveNext()`方法時，都會執(zhí)行`FairCycle(n)`方法中的代碼，直到遇到下一個`yield return`語句。

使用`yield return`的運行過程如下：

1. 初始化時鐘位置p為1。2. 進入無限循環(huán)。3. 第一次調(diào)用`yield return`語句，返回當前時鐘位置p和數(shù)字n的配對`(p, n)`，即`(1, 4)`。此時，比賽表中的第一場比賽是1號選手對陣4號選手。4. 繼續(xù)循環(huán)，進入第二次調(diào)用`yield return`語句。- 計算左側(cè)數(shù)字l，它等于p加上i，即2。- 計算右側(cè)數(shù)字r，它等于p加上(n-1)-i，即3。- 使用`yield return`語句返回左側(cè)數(shù)字l和右側(cè)數(shù)字r的配對`(l, r)`，即`(2, 3)`。此時，比賽表中的第二場比賽是2號選手對陣3號選手。5. 更新時鐘位置p，使其加上n/2，即2。此時，時鐘位置p指向下一輪的起始位置。6. 回到步驟3，開始下一輪的配對。- 第三次調(diào)用`yield return`語句，返回當前時鐘位置p和數(shù)字n的配對`(p, n)`，即`(2, 4)`。此時，比賽表中的第三場比賽是2號選手對陣4號選手。- 繼續(xù)循環(huán)，進入第四次調(diào)用`yield return`語句。- 計算左側(cè)數(shù)字l，它等于p加上i，即3。- 計算右側(cè)數(shù)字r，它等于p加上(n-1)-i，即2。- 使用`yield return`語句返回左側(cè)數(shù)字l和右側(cè)數(shù)字r的配對`(l, r)`，即`(3, 2)`。此時，比賽表中的第四場比賽是3號選手對陣2號選手。- 更新時鐘位置p，使其加上n/2，即4。此時，時鐘位置p指向下一輪的起始位置。- 回到步驟3，開始下一輪的配對。由于此時時鐘位置p超過了(n-1)，即4，所以將其減去(n-1)，即得到1。此時，時鐘位置p重新指向下一輪的起始位置。- 第五次調(diào)用`yield return`語句，返回當前時鐘位置p和數(shù)字n的配對`(p, n)`，即`(1, 4)`。此時，比賽表中的第五場比賽是1號選手對陣4號選手。- 繼續(xù)循環(huán)，進入第六次調(diào)用`yield return`語句。- 計算左側(cè)數(shù)字l，它等于p加上i，即2。- 計算右側(cè)數(shù)字r，它等于p加上(n-1)-i，即3。- 使用`yield return`語句返回左側(cè)數(shù)字l和右側(cè)數(shù)字r的配對`(l, r)`，即`(2, 3)`。此時，比賽表中的第六場比賽是2號選手對陣3號選手。- 更新時鐘位置p，使其加上n/2，即2。此時，時鐘位置p指向下一輪的起始位置。- 回到步驟3，開始下一輪的配對。由于此時時鐘位置p超過了(n-1)，即4，所以將其減去(n-1)，即得到1。此時，時鐘位置p重新指向下一輪的起始位置。- ...

這樣，`yield return`語句會按需生成比賽對陣，每次調(diào)用時返回一個比賽對陣，并在下一次調(diào)用時從迭代器Enumerator上一次離開的地方繼續(xù)執(zhí)行。

現(xiàn)在，讓我們來看看直接使用`return`的運行過程：

1. 初始化時鐘位置p為1。2. 直接使用`return`語句返回當前時鐘位置p和數(shù)字n的配對`(p, n)`，即`(1, 4)`。此時，方法立即終止執(zhí)行，并將配對`(1, 4)`作為方法的結(jié)果返回。這意味著只會生成一個比賽對陣，即1號選手對陣4號選手。

使用`return`語句會立即終止方法的執(zhí)行，并將指定的值作為方法的結(jié)果返回。這意味著方法只會生成一個比賽對陣，并且無法再繼續(xù)執(zhí)行其他的代碼。

注：FairCycle方法設計為時鐘的模式是為了確保每個參賽球隊都能在錦標賽中與其他球隊公平地對抗一次。該方法的好處包括：

• 公平性：通過時鐘的模式(所有球隊對半匹配一次)，每支球隊都有機會與其他球隊進行比賽，確保了比賽的公平性。沒有球隊會被遺漏或被偏好，每個球隊都有相同的機會競爭。

• 競爭性：FairCycle方法確保了每支球隊都能面對各種對手，包括實力強大的球隊和實力較弱的球隊。這種多樣性的對手使得比賽更具競爭性，增加了球隊之間的激烈程度。

• 簡潔性：時鐘的模式使得比賽安排更加簡潔明了。每支球隊在每輪比賽中都有一個確定的對手，沒有重復或遺漏的情況，減少了混亂和錯誤的可能性。

• 可預測性：由于時鐘的模式，每支球隊都可以提前知道在每一輪比賽中將要面對的對手。這樣，球隊可以提前制定戰(zhàn)術和策略，更好地準備比賽。

假設有8支球隊參加一個錦標賽，并且FairCycle方法被用來安排比賽。FairCycle方法的時鐘模式將確保每支球隊都能與其他球隊公平地對抗一次。

首先，我們將8支球隊編號為A、B、C、D、E、F、G、H。根據(jù)FairCycle方法，比賽的安排如下：

第一輪： A vs B C vs D E vs F G vs H

第二輪： A vs C B vs D E vs G F vs H

第三輪： A vs D B vs C E vs H F vs G

第四輪： A vs E B vs F C vs G D vs H

第五輪： A vs F B vs E C vs H D vs G

第六輪： A vs G B vs H C vs E D vs F

第七輪： A vs H B vs G C vs F D vs E

通過這個例子，我們可以看到每支球隊都與其他球隊公平地對抗了一次。FairCycle方法的時鐘模式確保了每支球隊都有相同的機會競爭，沒有球隊被遺漏或被偏好。這種安排方式確保了比賽的公平性，并且每支球隊都有機會面對各種對手，增加了比賽的競爭性。

測試用例：

using NUnit.Framework;
using System;
using System.Linq;
using System.Collections.Generic;
namespace Solution {
[TestFixture]
public class SolutionTest
{
[Test]
public void Test2Teams()
{
var expected = new []{ new []{(1, 2)} };
var actual = Tournament.BuildMatchesTable(2);
Assert.That(actual, Has.Length.EqualTo(1), "Should have 1 round");
Assert.That(actual[0], Has.Length.EqualTo(1), "The round should have 1 match");
if(actual[0][0].Item1>actual[0][0].Item2) (actual[0][0].Item1, actual[0][0].Item2) = (actual[0][0].Item2, actual[0][0].Item1);
Assert.AreEqual(expected, actual, "The match should be team 1 vs team 2");
}
[Test]
public void Test4Teams() => TestTeams(4);
[Test]
public void Test20Teams() => TestTeams(20);
[Test]
public void TestRandom()
{
Random rand = new Random();
TestTeams(2*(3+rand.Next(3)));
TestTeams(2*(6+rand.Next(4)));
}
public void TestTeams(int numberOfTeams)
{
List<int> teamsExpected = Enumerable.Range(1, numberOfTeams).ToList();
HashSet<(int, int)> matchesExpected = new HashSet<(int, int)>();
foreach(var round in TournamentSolution.BuildMatchesTable(numberOfTeams))
{
foreach(var game in round) matchesExpected.Add(game.Item1>game.Item2?(game.Item2,game.Item1):(game.Item1, game.Item2));
}
var actual = Tournament.BuildMatchesTable(numberOfTeams);
Assert.That(actual, Has.Length.EqualTo(numberOfTeams-1), $"Should have {numberOfTeams-1} rounds");
foreach(var round in actual)
{
List<int> teamsByRound = new List<int>();
Assert.That(round, Has.Length.EqualTo(numberOfTeams/2), $"Each round should have {numberOfTeams/2} matches");
foreach(var game in round)
{
Assert.That(game, Is.InstanceOf(typeof((int, int))), "Each match is a tupple of 2 teams");
teamsByRound.Add(game.Item1);
teamsByRound.Add(game.Item2);
Assert.True(matchesExpected.Remove(game.Item1>game.Item2?(game.Item2,game.Item1):(game.Item1, game.Item2)), $"{game} is a duplicate or doesn't exist");
}
teamsByRound.Sort();
Assert.AreEqual(teamsExpected, teamsByRound, "Each round should have matches with every team");
}
Assert.IsEmpty(matchesExpected, "At least one match isn't scheduled");
}
}
}
public class TournamentSolution
{
public static (int, int)[][] BuildMatchesTable(int numberOfTeams)
{
List<int> teams = Enumerable.Range(1, numberOfTeams).ToList();
int roundsNbr = numberOfTeams-1, gamesNbr = numberOfTeams /2, rotatorID = roundsNbr-1, buffer = 0;
(int, int)[][] result = new (int, int)[roundsNbr][];
for (int i=0; i<roundsNbr; i++)
{
result[i] = new (int, int)[gamesNbr];
for (int j = 0; j < gamesNbr; j++) result[i][j] = (teams[0 + j], teams[roundsNbr - j]);
buffer = teams[rotatorID];
teams.RemoveAt(rotatorID);
teams.Insert(0, buffer);
}
return result;
}
}

到此這篇關于c#中的yield return用法的文章就介紹到這了,更多相關c# yield return內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論