tournament-system 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf472f14954ad05551b972f6001a53dbfdbe9f0a
-  data.tar.gz: 41769df3e3b025ff4f4b0986e33585e845b37fcd
+  metadata.gz: 8079e2152df4c6c3ba2f084b80ed9b0c25f24135
+  data.tar.gz: 80e2cbcaccdbf8f4a96543ea02327722ef0519b2
 SHA512:
-  metadata.gz: b38f47ed72a2a1765f78b9d706702670cf4aa84457dc399c41fdce30f7e0f2a3dfc0b5ac8ea6a27fd95e93a7726c7629d9067b784f27458a09b37b1d624ba63c
-  data.tar.gz: 658ec1108455ad0902c288c2d510588a91d07be6dc8200c759784d79b2e74eef3ecda3864334b53af8b6f563ffe1d7ed48c234d4505ab8c56bc9a90fc5848c9c
+  metadata.gz: 98ca2b3ca59a77928148846a64a0020a511a34456694e15b9c2b1c60b8dfba60957c1814dec414e6aa3b14dbfd5ced19568dae3353cd06346297f6d23cae9035
+  data.tar.gz: bb76ea854b4f13efc63205c4c2e0555a92b99b2a2659449ad41e561ce66cc4aa9f00b6e61d41640586cd96bebf349f1e0e2833ecb788a4d577c4ba8fa87fc222

data/lib/tournament/algorithm/page_playoff.rb

@@ -0,0 +1,34 @@
+module Tournament
+  module Algorithm
+    # This module provides algorithms for dealing with the page playoff system.
+    module PagePlayoff
+      extend self
+
+      # The total number of rounds needed for all page playoff tournaments.
+      TOTAL_ROUNDS = 3
+
+      # :reek:ControlParameter
+
+      # Guess the next round (starting at 0) for page playoff.
+      #
+      # @param matches_count [Integer] the number of existing matches
+      # @return [Integer]
+      # @raise [ArgumentError] when the number of matches doesn't add up
+      def guess_round(matches_count)
+        round = MATCH_ROUND_MAP[matches_count]
+
+        raise ArgumentError, 'Invalid number of matches' unless round
+
+        round
+      end
+
+      private
+
+      MATCH_ROUND_MAP = {
+        0 => 0,
+        2 => 1,
+        3 => 2,
+      }.freeze
+    end
+  end
+end

data/lib/tournament/algorithm/pairers/adjacent.rb

@@ -0,0 +1,21 @@
+module Tournament
+  module Algorithm
+    module Pairers
+      # Basic pairer for adjacent teams.
+      module Adjacent
+        extend self
+
+        # Pair adjacent teams.
+        #
+        # @example
+        #   pair([1, 2, 3, 4]) #=> [[1, 2], [3, 4]]
+        #
+        # @param teams [Array<team>]
+        # @return [Array<Array(team, team)>]
+        def pair(teams)
+          teams.each_slice(2).to_a
+        end
+      end
+    end
+  end
+end

data/lib/tournament/algorithm/pairers/best_min_duplicates.rb

@@ -0,0 +1,55 @@
+require 'tournament/algorithm/util'
+
+module Tournament
+  module Algorithm
+    module Pairers
+      # Complex pairing system that tries to maximise uniqueness and
+      # total score difference.
+      module BestMinDuplicates
+        extend self
+
+        # Pair by minimising the number of duplicate matches,
+        # then minimising the score difference.
+        #
+        # @see Util.all_perfect_matches
+        #
+        # @param teams [Array<team>] the teams to pair
+        # @param scores [Hash{team => Numer}] a mapping from teams to scores
+        # @param matches_counts [Hash{Set(team, team) => Integer}]
+        #   A mapping from unique matches to their number of previous
+        #   occurrences.
+        def pair(teams, scores, matches_counts)
+          # enumerate all unique pairings using round robin
+          perfect_matches = Util.all_perfect_matches(teams, 2)
+
+          # Find all possible pairings with minimum duplicates
+          min_pairings = perfect_matches.group_by do |matches|
+            count_duplicate_matches(matches_counts, matches)
+          end.min_by(&:first).last
+
+          # Pick the pairings with least total score difference
+          min_pairings = Util.all_min_by(min_pairings) do |matches|
+            score_difference(scores, matches)
+          end
+
+          # Pick the last one as its usually the most diverse
+          min_pairings.last
+        end
+
+        private
+
+        def count_duplicate_matches(matches_counts, matches)
+          matches.map { |match| matches_counts[Set.new match] || 0 }.reduce(:+)
+        end
+
+        def score_difference(scores, matches)
+          # Default to a score of 0
+          score_h = Hash.new { |hash, key| hash[key] = scores[key] || 0 }
+
+          matches.map { |match| (score_h[match[0]] - score_h[match[1]]).abs }
+                 .reduce(:+)
+        end
+      end
+    end
+  end
+end

data/lib/tournament/algorithm/pairers/halves.rb

@@ -0,0 +1,32 @@
+module Tournament
+  module Algorithm
+    module Pairers
+      # Basic pairer that matches the top half with the bottom half
+      module Halves
+        extend self
+
+        # Pair the top half of teams with the bottom half.
+        #
+        # @example
+        #   pair([1, 2, 3, 4]) #=> [[1, 3], [2, 4]]
+        #
+        # @example
+        #   pair([1, 2, 3, 4], bottom_reversed: true) #=> [[1, 4], [2, 3]]
+        #
+        # @param teams [Array<team>]
+        # @param bottom_reversed [Boolean] whether to reverse the bottom half
+        #                                  before pairing both halves.
+        # @return [Array<Array(team, team)>]
+        # :reek:BooleanParameter
+        # :reek:ControlParameter
+        def pair(teams, bottom_reversed: false)
+          top, bottom = teams.each_slice(teams.length / 2).to_a
+
+          bottom.reverse! if bottom_reversed
+
+          top.zip(bottom).to_a
+        end
+      end
+    end
+  end
+end

data/lib/tournament/algorithm/pairers/multi.rb

@@ -0,0 +1,33 @@
+module Tournament
+  module Algorithm
+    module Pairers
+      # Modular pairer for combining multiple pairing algorithms.
+      module Multi
+        extend self
+
+        # Generic way of combining multiple pairing algorithms.
+        #
+        # Given a set of pair functions, generate pairs using each of them and
+        # use the block to determine a value for this pairing. The function will
+        # return the pairing generated that produced the highest score.
+        #
+        # @param pair_funcs [Array<lambda>] the array of pairers
+        # @yieldparam pairings [] a set of pairings generated by +pair_funcs+
+        # @yieldreturn [Number] a score for the set of pairings
+        # @return the set of pairings with the highest score
+        def pair(pair_funcs)
+          # Score all pairings
+          pairings = pair_funcs.map do |pair_func|
+            matches = pair_func.call
+            score = yield matches
+
+            [matches, score]
+          end
+
+          # Use the pairings with the highest score
+          pairings.max_by { |pair| pair[1] }.first
+        end
+      end
+    end
+  end
+end

data/lib/tournament/algorithm/pairers.rb

@@ -0,0 +1,7 @@
+module Tournament
+  module Algorithm
+    # This module provides multiple pairing algorithms
+    module Pairers
+    end
+  end
+end

data/lib/tournament/algorithm/round_robin.rb

@@ -0,0 +1,60 @@
+require 'tournament/algorithm/util'
+require 'tournament/algorithm/pairers/halves'
+
+module Tournament
+  module Algorithm
+    # This module provides algorithms for dealing with round robin tournament
+    # systems.
+    module RoundRobin
+      extend self
+
+      # Calculates the total number of rounds needed for round robin with a
+      # certain amount of teams.
+      #
+      # @param teams_count [Integer] the number of teams
+      # @return [Integer] number of rounds needed for round robin
+      def total_rounds(teams_count)
+        Util.padded_teams_count(teams_count) - 1
+      end
+
+      # Guess the next round (starting at 0) for round robin.
+      #
+      # @param teams_count [Integer] the number of teams
+      # @param matches_count [Integer] the number of existing matches
+      # @return [Integer] next round number
+      def guess_round(teams_count, matches_count)
+        matches_count / (Util.padded_teams_count(teams_count) / 2)
+      end
+
+      # Rotate array using round robin.
+      #
+      # @param array [Array<>] array to rotate
+      # @param round [Integer] the round number, ie. amount to rotate by
+      def round_robin(array, round)
+        rotateable = array[1..-1]
+
+        [array[0]] + rotateable.rotate(-round)
+      end
+
+      # Enumerate all round robin rotations.
+      def round_robin_enum(array)
+        Array.new(total_rounds(array.length)) do |index|
+          round_robin(array, index)
+        end
+      end
+
+      # Rotates teams and pairs them for a round of round robin.
+      #
+      # Uses {Pairers::Halves} for pairing after rotating.
+      #
+      # @param teams [Array<team>] teams playing
+      # @param round [Integer] the round number
+      # @return [Array<Array(team, team)>] the paired teams
+      def round_robin_pairing(teams, round)
+        rotated = round_robin(teams, round)
+
+        Pairers::Halves.pair(rotated, bottom_reversed: true)
+      end
+    end
+  end
+end

data/lib/tournament/algorithm/single_bracket.rb

@@ -0,0 +1,104 @@
+require 'ostruct'
+
+module Tournament
+  module Algorithm
+    # This module provides algorithms for dealing with single bracket
+    # elimination tournament systems.
+    module SingleBracket
+      extend self
+
+      # Calculates the total number of rounds needed for a single bracket
+      # tournament with a certain number of teams.
+      #
+      # @param teams_count [Integer] the number of teams
+      # @return [Integer] number of rounds needed for round robin
+      def total_rounds(teams_count)
+        Math.log2(teams_count).ceil
+      end
+
+      # Calculates the maximum number of teams that can play in a single bracket
+      # tournament with a given number of rounds.
+      #
+      # @param rounds [Integer] the number of rounds
+      # @return [Integer] number of teams that could play
+      def max_teams(rounds)
+        2**rounds
+      end
+
+      # Guess the next round (starting at 0) for a single bracket tournament.
+      #
+      # @param teams_count [Integer] the number of teams
+      # @param matches_count [Integer] the number of existing matches
+      # @return [Integer] next round number
+      # @raise [ArgumentError] when the number of matches does not add up
+      def guess_round(teams_count, matches_count)
+        rounds = total_rounds(teams_count)
+        total_teams = max_teams(rounds)
+
+        # Make sure we don't have too many matches
+        unless total_teams >= matches_count
+          raise ArgumentError, 'Too many matches'
+        end
+
+        round = rounds - Math.log2(total_teams - matches_count)
+        unless (round % 1).zero?
+          # Make sure we don't have some weird number of matches
+          raise ArgumentError, 'Invalid number of matches'
+        end
+
+        round.to_i
+      end
+
+      # Padd an array of teams to the next highest power of 2.
+      #
+      # @param teams [Array<team>]
+      # @return [Array<team, nil>]
+      def padd_teams(teams)
+        required = max_teams(total_rounds(teams.length))
+
+        # Insert the padding at the bottom to give top teams byes first
+        Array.new(required) { |index| teams[index] }
+      end
+
+      # Seed teams for a single bracket tournament.
+      #
+      # Seed in a way that teams earlier in +teams+ always win against later
+      # ones, the first team plays the second in the finals, the 3rd and 4th get
+      # nocked out in the semi-finals, etc.
+      #
+      # Designed to be used with {Pairers::Adjacent}.
+      #
+      # @param teams [Array<Team>]
+      # @return [Array<team>]
+      # @raise [ArgumentError] when the number of teams is not a power of 2
+      def seed(teams)
+        unless (Math.log2(teams.length) % 1).zero?
+          raise ArgumentError, 'Need power-of-2 teams'
+        end
+
+        teams = teams.map.with_index do |team, index|
+          OpenStruct.new(team: team, index: index)
+        end
+        seed_bracket(teams).map(&:team)
+      end
+
+      private
+
+      # Recursively seed the top half of the teams and match teams reversed by
+      # index to the bottom half.
+      def seed_bracket(teams)
+        return teams if teams.length <= 2
+
+        top_half, bottom_half = teams.each_slice(teams.length / 2).to_a
+        top_half = seed_bracket top_half
+
+        top_half.map do |team|
+          # match with the team appropriate team in the bottom half
+          match = bottom_half[-team.index - 1]
+
+          [team, match]
+        end.flatten
+      end
+    end
+  end
+end

data/lib/tournament/algorithm/swiss.rb

@@ -0,0 +1,83 @@
+module Tournament
+  module Algorithm
+    # This module provides algorithms for dealing with swiss tournament systems.
+    # Specifically it provides algorithms for grouping teams.
+    #
+    # @see Pairers Pairers for possible use with swiss.
+    module Swiss
+      extend self
+
+      # Calculates the minimum number of rounds needed to properly order teams
+      # using the swiss tournament system.
+      #
+      # @param teams_count [Integer] the number of teams
+      # @return [Integer]
+      def minimum_rounds(teams_count)
+        Math.log2(teams_count).ceil
+      end
+
+      # Groups teams by their score.
+      #
+      # @param teams [Array<team>] the teams to group
+      # @param scores [Hash{team => Number}] the scores of each team
+      # @return [Array<Array<team>>] groups of teams sorted
+      #                              with the highest score at the front
+      def group_teams_by_score(teams, scores)
+        groups = teams.group_by { |team| scores[team] || 0 }
+        sorted_keys = groups.keys.sort.reverse
+
+        sorted_keys.map { |key| groups[key] }
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # :reek:DuplicateMethodCall
+
+      # Merge small groups to the right (if possible) such that all groups
+      # are larger than min_size.
+      # Merging is performed in-place.
+      #
+      # @param groups [Array<Array<team>>] groups of teams
+      # @param min_size [Integer] the minimum size of groups
+      # @return [void]
+      def merge_small_groups(groups, min_size)
+        # Iterate all groups up until the last
+        index = 0
+        while index < groups.length - 1
+          # Merge group to the right until this group is large enough
+          while groups[index].length < min_size && index + 1 < groups.length
+            groups[index] += groups.delete_at(index + 1)
+          end
+
+          index += 1
+        end
+
+        # Merge the last group to the left if its too small
+        if groups[-1].length < min_size && groups.length != 1
+          last = groups.delete_at(-1)
+          groups[-1] += last
+        end
+
+        nil
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      # Rollover the last person in each group if its odd.
+      # This assumes that the total number of players in all groups is even.
+      # Rollover is performed in-place.
+      #
+      # @param groups [Array<Array<team>>] groups of teams
+      # @return [void]
+      def rollover_groups(groups)
+        groups.each_with_index do |group, index|
+          # Move last from the current group to the front of the next group
+          groups[index + 1].unshift group.pop if group.length.odd?
+        end
+
+        # Remove any empty groups
+        groups.reject!(&:empty?)
+
+        nil
+      end
+    end
+  end
+end