ruby-on-rails - 如何在 Ruby 中对世界杯小组赛表进行排序

Question

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

[
  { 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. 最大的目标
   • 如果有领带则使用以下
4. 并列球队之间的比赛中得分最高
5. 平局球队之间的最大进球差距
6. 平局球队比赛中的最大进球数
7. 抽签

问题

我的排序函数满足前三个条件。我如何更改它以说明存在双向或三向关系的情况？

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

三向并列的例子

[
  { 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(分数)淘汰斯洛文尼亚。

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

表格应该是这样的:

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

Algolia 以净胜球优势获胜(标准 5)。英格兰位居第二，因为它的目标 比美国(标准 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

Answer 1

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

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

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