java - 我将如何让一组团队一次又一次地互相比赛？

Question

我不知道如何让他们互相玩一次，而且只有一次。例如，这里是一个团队示例（我稍后会添加评分，主要是寻找逻辑帮助）：

class MyTeams {
    String teamName;
    int wins;
    int losses;
}

public class BasketallSeason {

    public static void main(String[] args) {

        MyTeams aoTeams[] = new MyTeams[9];

        aoTeams[0].teamName = "Utah";
        aoTeams[1].teamName = "USC";
        aoTeams[2].teamName = "Saint Mary's";
        aoTeams[3].teamName = "Oregon";
        aoTeams[4].teamName = "San Diego";
        aoTeams[5].teamName = "San Francisco";
        aoTeams[6].teamName = "UCLA";
        aoTeams[7].teamName = "Washington";
        aoTeams[8].teamName = "Loyola";
    }
}

score 5 · Accepted Answer

这是给你的基本算法

拿阵第一队
让该团队与阵列中的所有其他团队比赛
从阵列中删除该团队，或以其他方式将该团队标记为已经玩过所有人，以便您忽略它。
重复

score 3 · Accepted Answer

我实际上花了一些时间并编写了答案。这是一个非常有趣的问题。有很多方法可以解决这个问题：

花式迭代
递归
退出团队时进行迭代
使用单独的结构将团队“标记”为已处理

这张图片可能会有所帮助：

  0 1 2 3
0 - A A A
1 B - A A
2 B B - A
3 B B B -

该矩阵的 X 和 Y 轴显示您想要的答案。Set A 或 Set B 都会给你答案。请注意，您不希望团队像矩阵中的破折号所示那样自行比赛。以下是使用迭代的 3 个选项：

public class BBall {

public static void main(String args[]) {

    List<String> teams = new ArrayList<String>();
    teams.add("Boston");
    teams.add("LA");
    teams.add("New York");
    teams.add("Chicago");
    teams.add("Dallas");

    // This option might be a little easier to read.
    int index1 = 0;
    System.out.println("Easy to read:");
    for (String team1 : teams) {
        index1++;
        for (int index2 = index1; index2 < teams.size(); ++index2) {
            System.out.println(team1 + " plays " + teams.get(index2));
        }
    }
    System.out.println("This is set A:");
    for (int x = 1; x < teams.size(); x++) {
        for (int y = x - 1; y >= 0; y--) {
            System.out.println(teams.get(x) + " plays " + teams.get(y));
        }
    }
    System.out.println("This is set B:");
    for (int x = 0; x < teams.size() - 1; x++) {
        for (int y = x + 1; y < teams.size(); y++) {
            System.out.println(teams.get(x) + " plays " + teams.get(y));
        }
    }
}
}

输出：

易于阅读：

    Boston plays LA
    Boston plays New York
    Boston plays Chicago
    Boston plays Dallas
    LA plays New York
    LA plays Chicago
    LA plays Dallas
    New York plays Chicago
    New York plays Dallas
    Chicago plays Dallas

这是设置A：

    LA plays Boston
    New York plays LA
    New York plays Boston
    Chicago plays New York
    Chicago plays LA
    Chicago plays Boston
    Dallas plays Chicago
    Dallas plays New York
    Dallas plays LA
    Dallas plays Boston

这是B组：

    Boston plays LA
    Boston plays New York
    Boston plays Chicago
    Boston plays Dallas
    LA plays New York
    LA plays Chicago
    LA plays Dallas
    New York plays Chicago
    New York plays Dallas
    Chicago plays Dallas

score 1 · Accepted Answer

定义两个嵌套for循环，每个循环遍历您的团队。通常情况下，这将让每支球队与其他球队比赛两次，每支球队将自己比赛一次。

您不希望这样，因此将内for循环的循环变量初始化为外循环的循环变量的当前值加一for。这确保了团队的每个组合都只迭代一次，并且团队不会自己玩。

然后调用内部for循环中的任何游戏逻辑。

score 1 · Accepted Answer

像这样循环：

for(int i = 0; i < aoTeams.length - 1; i++) {
     for(int j = i+1; j < aoTeams.length; j++) {
         aoTeams[i].playAgainst(aoTeams[j]);
     }
}

score 1 · Accepted Answer

应该是对的：

for (int i = aoTeams.length-1; i >= 0; i--)
    for (int j = i-1; j >= 0; j--)
        System.out.println(aoTeams[j].teamName + " : "+ aoTeams[i].teamName);

不要忘记在 java 中的类中使用第一个大写字母，并始终以驼峰形式编写字段，以小写字母开头；-)

score 0 · Accepted Answer

在您的类中维护一个java.util.BitSet引用，myTeams并使用与团队数量相等的数字对其进行实例化。默认情况下，所有值在开始时都未设置(false)。

当一支球队试图与另一支球队进行比赛时，aoTeams检查BitSet对手数组索引中的值。如果未设置，则让它播放并在该索引处设置值。对其他团队也这样做。

示例实现可能如下所示：

class Team {

    String teamName;
    int wins;
    int losses;
    BitSet playRecord;

    public Team(String name, int size) {
        this.teamName = name;
        playRecord = new BitSet(size);
    }

    public boolean hasPlayed(int index) {
        return playRecord.get(index);
    }

    public void finishedPlaying(int index) {
        playRecord.set(index);
    }

}

这就是你使用它的方式：

public static void main(String[] args) {
    int size = 9;
    Team aoTeams[] = new Team[size];
    aoTeams[0] = new Team("Utah", size);
    aoTeams[1] = new Team("USC", size);
    play(aoTeams, 0, 1);
}

private static void play(Team[] teams, int indexA, int indexB) {
    if (teams[indexA].hasPlayed(indexB)) {
        // Teams have already played together
    } else {
        // Teams playing for the first time
        teams[indexA].finishedPlaying(indexB);
        teams[indexB].finishedPlaying(indexA);
    }
}

score 0 · Accepted Answer

在 myTeams 类中创建一个布尔数组（比如 alreadyPlayed），在构造函数中将它们初始化为全部 false，当 team1 与 team2 一起玩时，设置 alreadyPassed[2] = true（在 team1 的对象中）并在 team2 的对象中设置 alreadyPassed[1] = true .

score 0 · Accepted Answer

一个简单的嵌套循环。遍历两个列表并发出对，在第一个循环索引的 1+ 处开始第二个循环。

java - 我将如何让一组团队一次又一次地互相比赛？

8 回答 8

Related

Reference