Sistema de todos contra todos


El sistema de todos contra todos o sistema de liga es un sistema de torneos de competición, generalmente deportiva, en que cada participante o equipo del torneo se enfrenta contra todos los demás en eventos o juegos que involucran una competencia de pares, es decir un equipo contra otro equipo, y en un número constante de oportunidades (habitualmente una o dos).[1][2]​ Este tipo de competición es también llamado liguilla o round-robin. Un torneo de todos contra todos puede adoptar un nombre particular según la cantidad de participantes —como triangular, cuadrangular, pentagonal, hexagonal, etc.—. Este sistema se diferencia del torneo de eliminación, donde el perdedor no participa más y el ganador pasa a una siguiente fase; en el sistema de liga el perdedor sigue participando hasta jugar contra cada uno de los competidores.

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

En algunas copas internacionales importantes —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 una primera fase, 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.

Índice

Desventajas del método


Una desventaja, en especial cuando hay pocos competidores, es el "círculo de la muerte", donde los equipos no pueden ser separados en un puntaje de mayor a menor. En un round-robin de tres equipos donde A derrota a B, B derrota a C, y C derrota a A, todos los tres competidores tuvieron un récord de una victoria y una derrota, y un método de romper el empate necesitará ser usado para separar los equipos.[3]​ Este hecho sucedió con el Grupo E en la Copa del Mundo de 1994.

Criterios de clasificación


Los participantes de un torneo de este tipo en general son clasificados en tablas, para poder valorar su actuación. Estas tablas aplican diversos criterios de acuerdo con 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 con pocos participantes, la puntuación no basta para determinar todas las posiciones, por lo que se usan diversos criterios de desempate, que varían en cada torneo. Lo más habitual es considerar los goles anotados y recibidos, en distintas combinaciones.

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
Italia 7 3 2 1 0 7 3 4
Chile 3 3 0 3 0 4 4 0
Austria 2 3 0 2 1 3 4 -1
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


Si \({\displaystyle n}\) es el número de competidores, una ronda simple de este sistema requiere \({\displaystyle {\begin{matrix}{\frac {n(n-1)}{2}}\end{matrix}}}\) encuentros. Si \({\displaystyle n}\) es un número par, entonces en \({\displaystyle (n-1)}\) rondas, se pueden jugar \({\displaystyle {\begin{matrix}{\frac {n}{2}}\end{matrix}}}\) partidos simultáneamente. Si \({\displaystyle n}\) es impar, habrá \({\displaystyle n}\) rondas con \({\displaystyle {\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, con el fin de establecer el equipo que quedará libre. Para dobles rondas, simplemente se repite el sistema anterior, pero se alternan las localías.

Elaboración de fixture


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.ª 1 2 3 4
2.ª 5 6 7 1
3.ª 2 3 4 5
4.ª 6 7 1 2
5.ª 3 4 5 6
6.ª 7 1 2 3
7.ª 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.ª 1-8 2 3 4
2.ª 8-5 6 7 1
3.ª 2-8 3 4 5
4.ª 8-6 7 1 2
5.ª 3-8 4 5 6
6.ª 8-7 1 2 3
7.ª 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.ª 1-8 2-7 3-6 4-5
2.ª 8-5 6-4 7-3 1-2
3.ª 2-8 3-1 4-7 5-6
4.ª 8-6 7-5 1-4 2-3
5.ª 3-8 4-2 5-1 6-7
6.ª 8-7 1-6 2-5 3-4
7.ª 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 juego.

Algoritmos de programación


// Cálculo de liga usando algoritmo fixture

package generaliga;

public class Liga {

   static public class Partido
   {
       public int local = -1, visitante = -1;
   }
   private static Partido[][] calcularLigaNumEquiposPar(int numEquipos)
   {
       int numRondas = numEquipos - 1;
       int numPartidosPorRonda = numEquipos / 2;
       
       Partido[][] rondas = new Partido[numRondas][numPartidosPorRonda];
       
       for (int i = 0, k = 0; i < numRondas; i ++)
       {
           for (int j = 0; j < numPartidosPorRonda; j ++)
           {
               rondas[i][j] = new Partido();
               
               rondas[i][j].local = k;
               k ++;
               if (k == numRondas)
                   k = 0;
           }
       }
       
       for (int i = 0; i < numRondas; i ++)
       {
           if (i % 2 == 0)
           {
               rondas[i][0].visitante = numEquipos - 1;
           }
           else
           {
               rondas[i][0].visitante = rondas[i][0].local;
               rondas[i][0].local = numEquipos - 1;
           }
       }
       
       int equipoMasAlto = numEquipos - 1;
       int equipoImparMasAlto = equipoMasAlto - 1; 
       
       for (int i = 0, k = equipoImparMasAlto; i < numRondas; i ++)
       {
           for (int j = 1; j < numPartidosPorRonda; j ++)
           {
               rondas[i][j].visitante = k;
               k --;
               if (k == -1)
                   k = equipoImparMasAlto;
           }
       }
       
       return rondas;
   }
   private static Partido[][] calcularLigaNumEquiposImpar(int numEquipos)
   {
       int numRondas = numEquipos;
       int numPartidosPorRonda = numEquipos / 2;
       
       Partido[][] rondas = new Partido[numRondas][numPartidosPorRonda];
       
       for (int i = 0, k = 0; i < numRondas; i ++)
       {
           for (int j = -1; j < numPartidosPorRonda; j ++)
           {
               if (j >= 0)
               {
                   rondas[i][j] = new Partido();
                   
                   rondas[i][j].local = k;
               }
               
               k ++;
               if (k == numRondas)
                   k = 0;
           }
       }
       
       int equipoMasAlto = numEquipos - 1;
       
       for (int i = 0, k = equipoMasAlto; i < numRondas; i ++)
       {
           for (int j = 0; j < numPartidosPorRonda; j ++)
           {
               rondas[i][j].visitante = k;
               k --;
               if (k == -1)
                   k = equipoMasAlto;
           }
       }
       
       return rondas;
   }
   
   static public Partido[][] calcularLiga(int numEquipos)
   {
       if (numEquipos % 2 == 0)
           return calcularLigaNumEquiposPar(numEquipos);
       else
           return calcularLigaNumEquiposImpar(numEquipos);
   }
   
   static public void mostrarPartidos(Partido[][] rondas)
   {
       System.out.println("IDA");
       
       for (int i = 0; i < rondas.length; i ++)
       {
           System.out.print("Ronda " + (i + 1) + ": ");
           
           for (int j = 0; j < rondas[i].length; j ++)
           {
               System.out.print("   " + (1 + rondas[i][j].local) + "-" + (1 + rondas[i][j].visitante));
           }
           
           System.out.println();
       }
       
       System.out.println("VUELTA");
       
       for (int i = 0; i < rondas.length; i ++)
       {
           System.out.print("Ronda " + (i + 1) + ": ");
           
           for (int j = 0; j < rondas[i].length; j ++)
           {
               System.out.print("   " + (1 + rondas[i][j].visitante) + "-" + (1 + rondas[i][j].local));
           }
           
           System.out.println();
       }
   }
   static public void main(String[] args)
   {
       System.out.println("Liga con 10 equipos:");
       
       mostrarPartidos(calcularLiga(10));
       
       System.out.println();
       
       System.out.println("Liga con 7 equipos:");
       
       mostrarPartidos(calcularLiga(7));
   }

} Liga con 8

equipos:

IDA Ronda 1: 1-8 2-7 3-6 4-5 Ronda 2: 8-5 6-4 7-3 1-2 Ronda 3: 2-8 3-1 4-7 5-6 Ronda 4: 8-6 7-5 1-4 2-3 Ronda 5: 3-8 4-2 5-1 6-7 Ronda 6: 8-7 1-6 2-5 3-4 Ronda 7: 4-8 5-3 6-2 7-1 VUELTA Ronda 1: 8-1 7-2 6-3 5-4 Ronda 2: 5-8 4-6 3-7 2-1 Ronda 3: 8-2 1-3 7-4 6-5 Ronda 4: 6-8 5-7 4-1 3-2 Ronda 5: 8-3 2-4 1-5 7-6 Ronda 6: 7-8 6-1 5-2 4-3 Ronda 7: 8-4 3-5 2-6 1-7

Liga con 7 equipos: IDA Ronda 1: 2-7 3-6 4-5 Ronda 2: 6-4 7-3 1-2 Ronda 3: 3-1 4-7 5-6 Ronda 4: 7-5 1-4 2-3 Ronda 5: 4-2 5-1 6-7 Ronda 6: 1-6 2-5 3-4 Ronda 7: 5-3 6-2 7-1 VUELTA Ronda 1: 7-2 6-3 5-4 Ronda 2: 4-6 3-7 2-1 Ronda 3: 1-3 7-4 6-5 Ronda 4: 5-7 4-1 3-2 Ronda 5: 2-4 1-5 7-6 Ronda 6: 6-1 5-2 4-3 Ronda 7: 3-5 2-6 1-7

PHP

$players = array('A','B','C','D');
$matches = array();foreach($players as $k){
	foreach($players as $j){
		if($k == $j){
			continue;
		}
		$z = array($k,$j);
		sort($z);
		if(!in_array($z,$matches)){
			$matches[] = $z;
		}
	}
}print_r($matches);
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

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
enddef 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)

Python3

tope = 8# modificar el numero de clubes
clubes = []10
index_clubes = 0
for i in range(0,tope):
   clubes.append("Club_"+str(i+1))auxT = len(clubes)
impar= True if auxT%2 != 0 else Falseif impar:
   auxT += 1totalP = auxT/2 # total de partidos de una jornada
jornada = []
indiceInverso = auxT-2for i in range(1,auxT):
   equipos = []
   list_equipos = {}
   for indiceP in range(0,totalP):
      if index_clubes > auxT-2:
         index_clubes = 0      if indiceInverso < 0:
         indiceInverso = auxT-2      if indiceP == 0: # seria el partido inicial de cada fecha
         if impar:
            equipos.append(clubes[index_clubes])
         else:
            if (i+1)%2 == 0:
               partido = [clubes[index_clubes], clubes[auxT-1]]
            else:
               partido = [clubes[auxT-1], clubes[index_clubes]]
            equipos.append(" vs ".join(partido))
      else:
         partido = [clubes[index_clubes], clubes[indiceInverso]]
         equipos.append(" vs ".join(partido))
         indiceInverso -= 1
      index_clubes += 1   list_equipos = {
      'jornada': "Jornada Nro.: " + str(i),
      'equipos': equipos
   }
   jornada.append(list_equipos)print(jornada)

Tenis


En el tenis se conoce particularmente con el nombre de round robin y es un sistema utilizado en algunos torneos como la ATP World Tour Finals, la WTA Finals y la Copa del Mundo por Equipos, el cual se basa en cuadros divididos en grupos de tres o cuatro jugadores, en los cuales el ganador de cada grupo avanza a una instancia de eliminación directa que se logra al estar en el juego con el formato.

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:

Véase también


Referencias


  1. Webster's Third New International Dictionary of the English Language, Unabridged (1971, G. & C. Merriam Co), p.1980.
  2. Orcutt, William Dana (1895). Official Lawn Tennis Bulletin 2. New York: The Editors. pp. 1, 3. 
  3. «UC Berkeley Quiz Bowl: How To Make Schedules» . www.ocf.berkeley.edu. Consultado el 14 de septiembre de 2021. 









Categorías: Terminología deportiva | Sistemas de competición




A partir de: 17.05.2022 02:54:16 CEST

Fuente: Wikipedia (Autores [Historia])    Licencia: CC-BY-SA-3.0

Modificaciónes: Se eliminaron todas las imágenes y la mayoría de los elementos de diseño relacionados con ellos. Algunos iconos fueron reemplazados por FontAwesome-Icons. Algunas plantillas se eliminaron (como "el artículo necesita expansión) o se asignaron (como" notas de sombrero "). Las clases CSS fueron eliminadas o armonizadas.
Se eliminaron los enlaces específicos de Wikipedia que no conducen a un artículo o categoría (como "Enlaces rojos", "enlaces a la página de edición", "enlaces a portales"). Cada enlace externo tiene un FontAwesome-Icon adicional. Además de algunos pequeños cambios de diseño, se eliminaron los contenedores de medios, mapas, cuadros de navegación, versiones habladas y Geo-microformatos.

Tenga en cuenta: Debido a que el contenido dado se toma automáticamente de Wikipedia en el momento dado, una verificación manual fue y no es posible. Por lo tanto, LinkFang.org no garantiza la precisión y la actualidad del contenido adquirido. Si hay una información que es incorrecta en este momento o tiene una pantalla incorrecta, no dude en Contáctenos: e-mail.
Ver también: Información legal & Política de privacidad.