我正在编写一种算法来根据比赛数据创建世界杯小组表并对其进行排序。因此，给出以下匹配数据：

[
  { id: 1, home_team: "Honduras", away_team: "Chile", home_score: 0, away_score: 1 },
  { id: 2, home_team: "Spain", away_team: "Switzerland", home_score: 0, away_score: 1 },
  { id: 3, home_team: "Chile", away_team: "Switzerland", home_score: 1, away_score: 0 },
  { id: 4, home_team: "Spain", away_team: "Honduras", home_score: 2, away_score: 0 },
  { id: 5, home_team: "Chile", away_team: "Spain", home_score: 1, away_score: 2 },
  { id: 6, home_team: "Honduras", away_team: "Switzerland", home_score: 0, away_score: 0 }
]

我的程序将产生这个（顺序很重要）：

[{ goals_for: 4, goals_against: 2, goal_diff: 2,  points: 6, name: "Spain" },
 { goals_for: 3, goals_against: 2, goal_diff: 1,  points: 6, name: "Chile" },
 { goals_for: 1, goals_against: 1, goal_diff: 0,  points: 4, name: "Switzerland" },
 { goals_for: 0, goals_against: 3, goal_diff: -3, points: 1, name: "Honduras" }]

这很好，除非存在双向或三向平局。那么标准就变得复杂了。这里按优先顺序排列：

1. 最大点数
2. 最大进球差距
3. Greatest goals for
   • 如果有平局，则使用以下内容
4. 平局球队之间的比赛中最多得分
5. 平局球队之间比赛的最大进球差异
6. 平局球队之间比赛的最大进球数
7. 抽签

Question

我的排序函数满足前三个标准。我如何更改它以考虑存在双向或三向关系的情况？

  def sort
    teams.sort_by! do |team|
      [ team[:points], team[:goal_diff], team[:goals_for] ]
    end.reverse!
  end

3 向领带示例

[
  { id: 1, home_team: "Algeria", away_team: "Slovenia", home_score: 2, away_score: 1 },
  { id: 2, home_team: "USA", away_team: "Slovenia", home_score: 5, away_score: 1 },
  { id: 3, home_team: "England", away_team: "Slovenia", home_score: 4, away_score: 0 },
  { id: 4, home_team: "Algeria", away_team: "USA", home_score: 3, away_score: 0 },
  { id: 5, home_team: "USA", away_team: "England", home_score: 2, away_score: 0 },
  { id: 6, home_team: "England", away_team: "Algeria", home_score: 3, away_score: 2 }
]

此示例将根据标准 1（分）淘汰斯洛文尼亚。

其余三队的排名则根据subset的比赛数据。该子集应仅包括平局球队之间的比赛。在这种情况下，我们将使用包括阿尔及利亚、英格兰和美国在内的所有比赛重建表格。我们排除涉及斯洛文尼亚的比赛。

该表应如下所示：

| POS | TEAM        | GF | GA | GD | POINTS |
| 1   | Algeria     | 5  | 3  |  2 | 3      |
| 3   | England     | 3  | 4  | -1 | 3      |
| 2   | USA         | 2  | 3  | -1 | 3      |

阿尔及利亚凭借净胜球获胜（标准 5）。英格兰位居第二是因为goals for高于美国（标准 6）。

我的程序实际上输出了这个，这是不正确的，因为它没有对关系做任何事情，并在标准 3 处停止。

[ { goals_for: 7, goals_against: 4, goal_diff: 3, points: 6, name: "England" },
  { goals_for: 7, goals_against: 4, goal_diff: 3, points: 6, name: "Algeria" },
  { goals_for: 7, goals_against: 4, goal_diff: 3, points: 6, name: "USA" },
  { goals_for: 2, goals_against: 11, goal_diff: -9, points: 0, name: "Slovenia" }]

这是完整的程序：

class Calculator
  attr_reader :games, :teams

  def initialize(games)
    defaults = { goals_for: 0, goals_against: 0, goal_diff: 0, points: 0 }
    @games = games
    @teams = games.each_with_object([]) do |game, arr|
      arr.push({ name: game[:home_team] }.merge!(defaults))
      arr.push({ name: game[:away_team] }.merge!(defaults))
    end.uniq
  end

  def build_table
    build
    sort
    return teams
  end

private

  def build
    games.each do |game|
      if game[:home_score].present? && game[:away_score].present?
        home_team = teams.detect { |team| team[:name] == game[:home_team] }
        away_team = teams.detect { |team| team[:name] == game[:away_team] }

        home_team[:goals_for]     += game[:home_score]
        home_team[:goals_against] += game[:away_score]

        away_team[:goals_for]     += game[:away_score]
        away_team[:goals_against] += game[:home_score]

        home_team[:goal_diff] = home_team[:goals_for] - home_team[:goals_against]
        away_team[:goal_diff] = away_team[:goals_for] - away_team[:goals_against]

        if game[:home_score] > game[:away_score]
          home_team[:points] += 3
        elsif game[:home_score] < game[:away_score]
          away_team[:points] += 3
        else
          home_team[:points] += 1
          away_team[:points] += 1
        end
      end
    end
  end

  def sort
    teams.sort_by! { |team| [ team[:points], team[:goal_diff], team[:goals_for] ] }.reverse!
  end
end

您有一组明确定义的规则来确定团队的排序方式。一种方法是编写一个排序例程，一次执行一个规则，并在找到获胜者时进行短路：

def compare_points(a, b)
  a[:points] <=> b[:points]
end

def compare_goal_diff(a, b)
  a[:goal_diff] <=> b[:goal_diff]
end

def compare_teams(a, b)
  comparison = compare_points(a, b)
  return comparison unless comparison.zero?

  comparison = compare_goal_diff(a, b)
  return comparison unless comparison.zero?
  # Repeat for each type of comparison
  # ...
  comparison.zero? ? flip_coin : comparison
end

teams.sort! { |a, b| compare_teams(a, b) }.reverse!

比较单个值（如点）时，比较运算符<=>足够。对于更复杂的比较，您需要深入研究@games数组来确定获胜者，例如：

  def compare_points_from_matches_between(a, b)
    # Hand-waving follows
    # case
    # when team A has fewer points than team B in their meetings
    #   -1
    # when team B has fewer points than team A in their meetings
    #   1
    # else
    #   0
    # end
  end

根据您的规则应用每个比较。在每个步骤中，如果比较非零，则返回该值；否则您将继续下一步。最后，如果比较仍然为零，则掷硬币。