Sistema de todos contra todos

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda

El sistema de todos contra todos o sistema de liga es un sistema de competición, generalmente deportiva, en que todos los participantes del torneo se enfrentan entre ellos en un número constante de oportunidades (generalmente una o dos). Este tipo de competición es también llamado liguilla o round-robin. Un torneo de todos contra todos se llama asimismo triangular, cuadrangular o hexagonal si la cantidad de participantes es tres, cuatro o seis.

Este torneo se utiliza habitualmente en las ligas nacionales de deportes de pelota como fútbol, baloncesto, rugby y béisbol, donde varios equipos se enfrentan en temporadas de medio año o año completo.

Durante las primeras rondas de algunas copas internacionales, como la Copa Mundial de Fútbol, la Liga de Campeones de la UEFA y la Copa Libertadores de América, se emplea un sistema de dos fases. En la fase de grupos, los equipos se dividen en grupos de pocos integrantes (generalmente cuatro), que se enfrentan en un sistema de todos contra todos. Los mejores equipos de cada grupo pasan a la segunda fase, que suele ser de eliminación directa.

Criterios de clasificación[editar]

Los participantes de un torneo de este tipo en general son clasificados en tablas para poder determinar su éxito. Estas tablas aplican diversos criterios de acuerdo a los resultados que determinan una puntuación a cada uno de los competidores. En el caso del fútbol, cada victoria entrega 3 puntos, 1 por cada empate y 0 por derrota. Este sistema fue adoptado gradualmente desde los años 1980 y años 1990, reemplazando al antiguo sistema de dos puntos por victoria y uno por empate.

En muchas oportunidades (especialmente en el caso de torneos de grupos con pocos participantes), la puntuación no basta para determinar todas las posiciones, por lo que se usan diversos criterios que varían en cada torneo.

La Copa Mundial de Fútbol, el principal torneo de selecciones nacionales de fútbol, utiliza los siguientes patrones de desempate en caso de que dos o más equipos terminen con idéntica cantidad de puntos:

  1. Mayor diferencia de goles.
  2. Mayor número de goles anotados.
  3. Mayor número de puntos obtenidos en los partidos disputados entre los equipos empatados.
  4. Mayor diferencia de goles en los partidos disputados entre los equipos empatados.
  5. Mayor número de goles anotados en los partidos disputados entre los equipos empatados.
  6. Sorteo del comité organizador.

Un ejemplo del sistema de clasificación es el siguiente, que corresponde al Grupo B de la Copa Mundial de Fútbol de 1998. Italia clasificó en el primer lugar al ganar dos de sus tres partidos y empatar un tercero, mientras Chile alcanzó tres puntos por tres empates. Austria quedó tercera pues, aunque tenía igual puntuación que Camerún, contaba con una mejor diferencia de goles (–1 contra –3).

Equipo Pts PT G E P GF GC DG
Bandera de Italia Italia 7 3 2 1 0 7 3 4
Bandera de Chile Chile 3 3 0 3 0 4 4 0
Bandera de Austria Austria 2 3 0 2 1 3 4 -1
Bandera de Camerún Camerún 2 3 0 2 1 2 5 -3
Italia 2:2 Chile
Camerún 1:1 Austria
Chile 1:1 Austria
Italia 3:0 Camerún
Italia 2:1 Austria
Chile 1:1 Camerún

Algoritmos de selección[editar]

Si n es el número de competidores, una ronda simple de este sistema requiere \begin{matrix} \frac{n(n-1)}{2} \end{matrix} encuentros. Si n es un número par, entonces en (n - 1) rondas, se pueden jugar \begin{matrix} \frac{n}{2} \end{matrix} partidos simultáneamente. Si n es impar, habrá n rondas con \begin{matrix} \frac{n - 1}{2} \end{matrix} juegos simultáneos y un equipo libre (sin jugar) por cada ronda.

Para determinar el calendario del torneo, se realiza un simple algoritmo de selección. A cada uno de los competidores se le asigna un número y se van rotando los números, dejando uno fijo. Por ejemplo, en un torneo con 14 equipos:

1ª ronda: (1 contra 14, 2 contra 13, … )
 1  2  3  4  5  6  7  
 14 13 12 11 10 9  8
2ª ronda: (1 contra 13, 14 contra 12, … )
 1  14 2  3  4  5  6
 13 12 11 10 9  8  7
3ª ronda: (1 contra 12, 13 contra 11, … )
 1  13 14 2  3  4  5
 12 11 10 9  8  7  6
13ª ronda: (1 contra 2, 3 contra 14, … )
 1  3  4  5  6  7  8
 2 14  13 12 11 10 9

Si hay un número impar, se puede asignar un número especial (para totalizar los pares) para designar al equipo que quedará libre. Para dobles rondas, simplemente se repite el sistema anterior, pero se alternan las localías.

Elaboración de fixture[editar]

Un fixture es una tabla de emparejamientos de equipos o jugadores en un torneo por sistema de "todos contra todos".

Para elaborar manualmente un fixture, se tiene en cuenta que la cantidad de rondas es igual al número de participantes menos 1, y la cantidad de enfrentamientos por ronda es igual a la mitad del número de participantes. Por ejemplo, un torneo de ocho participantes requiere siete rondas y cuatro enfrentamientos por ronda.

En este ejemplo de torneo con ocho participantes, se crea una tabla de siete filas (rondas) por cuatro columnas (juegos). La tabla se comienza escribiendo sucesivamente y hasta el final los números de los participantes hasta el impar más alto; es decir, que en este ejemplo se escriben los números del 1 al 7:

Ronda Partida 1 Partida 2 Partida 3 Partida 4
1 2 3 4
5 6 7 1
2 3 4 5
6 7 1 2
3 4 5 6
7 1 2 3
4 5 6 7

Si el número de participantes es par, el último número se escribe alternativamente a derecha e izquierda del número de la primera columna (si el número de participantes es impar, no se escribe dicho número y el participante de la primera columna queda libre en la ronda correspondiente):

Ronda Partida 1 Partida 2 Partida 3 Partida 4
1-8 2 3 4
8-5 6 7 1
2-8 3 4 5
8-6 7 1 2
3-8 4 5 6
8-7 1 2 3
4-8 5 6 7

Por último, se completan los emparejamientos por filas y columnas escribiendo hacia abajo los números faltantes empezando por el impar más alto:

Ronda Partida 1 Partida 2 Partida 3 Partida 4
1-8 2-7 3-6 4-5
8-5 6-4 7-3 1-2
2-8 3-1 4-7 5-6
8-6 7-5 1-4 2-3
3-8 4-2 5-1 6-7
8-7 1-6 2-5 3-4
4-8 5-3 6-2 7-1

El primer número en cada enfrentamiento tendrá la prioridad correspondiente (la condición de local, las piezas blancas en ajedrez, etc.). En caso de ser un torneo a doble vuelta, en la segunda se invierten los números de cada enfrentamiento.

Algoritmos de programación[editar]

JAVA[editar]

public void liga(){
   
   int tope=6;//modificar el numero de clubes
   List <String> clubes=new ArrayList<String>();
   for (int i=0; i<tope;i++){
      clubes.add("Club_"+Integer.toString(i));
   }
   int auxT=clubes.size();
   boolean impar=(auxT%2!=0);
   if(impar){
      ++auxT;
   }
   int totalP=(auxT*(auxT-1))/2;//total de partidos de una ronda
   String [] local=new String [totalP];
   String [] visita=new String [totalP];
   int modIF=(auxT/2);//para hacer mod cada inicio de fecha
   int indiceInverso=auxT-2;
   for(int i=0;i<totalP;i++){
      if (i%modIF==0){//seria el partido inicial de cada fecha
         //si es impar el numero de clubes la primera fecha se borra poniendo null
         if (impar){
            local[i]=null;
            visita[i]=null;
         }
         else{
            //se pone uno local otro  visita al ultimo equipo
            if(i%2==0){
               local[i]=clubes.get(i%(auxT-1));
               visita[i]=clubes.get(auxT-1);
            }
            else{
               local[i]=clubes.get(auxT-1);
                visita[i]=clubes.get(i%(auxT-1));
            }
         }
      }
      else{
         local[i]=clubes.get(i%(auxT-1));
         visita[i]=clubes.get(indiceInverso);           
         --indiceInverso;
         if (indiceInverso<0){
            indiceInverso=auxT-2;
         }
      }
   }
   for(int i=0;i<totalP;i++){
      if(local[i]!=null){
         System.out.println(local[i]+" vs "+visita[i]+"\n");
      }
   }
   System.out.println("\n Segunda ronda \n \n");
   for(int i=0;i<totalP;i++){
      if(local[i]!=null){
         System.out.println(visita[i]+" vs "+local[i]+"\n");
      }
   }
}

PHP[editar]

$players = array('A','B','C','D');
$matchs = array();

foreach($players as $k){
        foreach($players as $j){
                if($k == $j){
                        continue;
                }
                $z = array($k,$j);
                sort($z);
                if(!in_array($z,$matchs)){
                        $matchs[] = $z;
                }
        }
}

print_r($matchs);
Array(
    [0] => Array( [0] => A , [1] => B  ),
    [1] => Array( [0] => A , [1] => C  ),
    [2] => Array( [0] => A , [1] => D  ),
    [3] => Array( [0] => B , [1] => C  ),
    [4] => Array( [0] => B , [1] => D  ),
    [5] => Array( [0] => C , [1] => D  )
)

Ruby[editar]

class LeagueRounds
  attr_reader :teams, :home_rounds, :away_rounds

  def initialize(teams)
    @teams = teams
    @home_rounds = []
    @away_rounds = []
  end

  def rounds
    number_of_rounds.times do
      matches_home = []
      matches_away = []

      number_of_matches.times do |index|
        team_1 = teams[index]
        team_2 = teams[number_of_rounds - index]

        matches_home << [team_1, team_2]
        matches_away << [team_2, team_1]
      end

      home_rounds << matches_home
      away_rounds << matches_away

      rotate_teams!
    end

    return home_rounds + away_rounds
  end

  private

  def rotate_teams!
    last = teams.pop
    teams.insert(1, last)
  end

  def number_of_rounds
    @rounds ||= (teams.length - 2) + 1
  end

  def number_of_matches
    @matches ||= (teams.length / 2)
  end
end

def print_rounds(rounds)
  i = 1
  rounds.each do |round|
    puts "Round: #{i}"
    round.each do |match|
      puts "Match: #{match[0]} - #{match[1]}"
    end
    i += 1
  end
end


clubs = ("A".."T").collect {|x| x}
rounds = LeagueRounds.new(clubs).rounds
print_rounds(rounds)

Tenis[editar]

En el tenis se conoce particularmente con el nombre de round robin y es un sistema utilizado en algunos torneos como la Tennis Masters Cup y la Copa del Mundo por Equipos, el cual se basa en cuadros divididos en grupos de tres jugadores, en los cuales el ganador de cada grupo avanza a una instancia de eliminación directa.

Con este formato, lo que se pretende es incentivar el aumento de público, al dar más opciones de ver a sus jugadores favoritos en un mismo torneo.

Fue propuesto por la ATP para la temporada 2007, en trece torneos, como formato experimental. Sin embargo, el 20 de marzo de ese mismo año, debido a la molestia y confusión que generaba en muchos jugadores, se eliminó de los restantes torneos propuestos, después de haber sido implementado en cinco torneos.

Existen diversos tipos de torneo dependiendo del número de participantes:

  • 24 jugadores: son ocho grupos de tres tenistas. Cada uno juega al menos dos partidos. El ganador de cada grupo avanza a los cuartos de final donde se restablece la eliminación directa.
  • 32 jugadores: play-offs con 16 jugadores, de los cuales, ocho salen ganadores, sumándose a los 16 restantes. Se forman en ese momento ocho grupos de tres tenistas. Cada uno jugando al menos dos partidos. El ganador de cada grupo avanza a los cuartos de final donde se restablece la eliminación directa.
  • 48 jugadores: son dieciséis grupos de tres jugadores. Cada uno juega al menos dos partidos. El ganador de cada grupo avanza a los octavos de final donde se restablece la eliminación directa.