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

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

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

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

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

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

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

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

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

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

應(yīng)該返回一個元組矩陣，如下所示：

{
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
}

算法實(shí)現(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ù)組，表示當(dāng)前輪次的比賽對陣
for (int t = 0; t < n / 2; t++)
{
teams.MoveNext();  // 迭代到下一個比賽對陣
round[t] = teams.Current;  // 將當(dāng)前比賽對陣添加到當(dāng)前輪次的比賽表中
}
matches[i] = round;  // 將當(dāng)前輪次的比賽表添加到總的比賽表中
// FairCycle函數(shù)會在這里負(fù)責(zé)循環(huán)到下一個比賽對陣
}
return matches;  // 返回生成的比賽表
}
static IEnumerable<(int,int)> FairCycle(int n)
{
// 將數(shù)字1到n-1按順時針方式排列
// 從12點(diǎn)鐘方向開始，1位于12點(diǎn)鐘位置
int p = 1;
while (true)
{
// 返回n和12點(diǎn)鐘位置的數(shù)字
yield return (p, n);
// 然后返回12點(diǎn)鐘左右兩側(cè)的數(shù)字配對
// 例如，11和1點(diǎn)鐘，10和2點(diǎn)鐘，以此類推
for (int i = 1; i < n / 2; i++)
{
int l = p + i;
l = l > (n - 1) ? l - (n - 1) : l;  // 對n進(jì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點(diǎn)鐘位置
p += n / 2;
p = p > (n - 1) ? p - (n - 1) : p;
// 這將開始下一輪的配對
}
}

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

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

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

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

首先，我們調(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`的運(yùn)行過程如下：

1. 初始化時鐘位置p為1。2. 進(jìn)入無限循環(huán)。3. 第一次調(diào)用`yield return`語句，返回當(dāng)前時鐘位置p和數(shù)字n的配對`(p, n)`，即`(1, 4)`。此時，比賽表中的第一場比賽是1號選手對陣4號選手。4. 繼續(xù)循環(huán)，進(jì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`語句，返回當(dāng)前時鐘位置p和數(shù)字n的配對`(p, n)`，即`(2, 4)`。此時，比賽表中的第三場比賽是2號選手對陣4號選手。- 繼續(xù)循環(huán)，進(jì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`語句，返回當(dāng)前時鐘位置p和數(shù)字n的配對`(p, n)`，即`(1, 4)`。此時，比賽表中的第五場比賽是1號選手對陣4號選手。- 繼續(xù)循環(huán)，進(jì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`的運(yùn)行過程：

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

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

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

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

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

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

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

假設(shè)有8支球隊參加一個錦標(biāo)賽，并且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方法的時鐘模式確保了每支球隊都有相同的機(jī)會競爭，沒有球隊被遺漏或被偏好。這種安排方式確保了比賽的公平性，并且每支球隊都有機(jī)會面對各種對手，增加了比賽的競爭性。

測試用例：

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;
}
}

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

最新評論