Este artículo o sección tiene referencias pero necesita más para complementar su verificabilidad Busca fuentes Sistema d

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 Copa América, la Eurocopa, la Liga de Campeones de la UEFA y la Copa Libertadores de América—, se emplea un sistema de dos fases. En una primera etapa, los equipos se dividen en grupos de pocos integrantes, generalmente cuatro, que se enfrentan todos contra todos. Los mejores de cada grupo pasan a la segunda etapa, que es de eliminación directa.

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.

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:

Mayor diferencia de goles.
Mayor número de goles anotados.
Mayor número de puntos obtenidos en los partidos disputados entre los equipos empatados.
Mayor diferencia de goles en los partidos disputados entre los equipos empatados.
Mayor número de goles anotados en los partidos disputados entre los equipos empatados.
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 $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, 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 elaborarlo manualmente, 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 o partidas). 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, hasta completar las siete filas.

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

A continuación, si el número de participantes es par, ese 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 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 y sucesivamente 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

Fixture

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

Python3

tope = 8 # Modificar el número de clubes clubes = [] for i in range(1, tope + 1): clubes.append("Club_" + str(i)) auxT = len(clubes) impar = auxT % 2 != 0 if impar: auxT += 1 totalP = auxT // 2 # Total de partidos de una jornada jornada = [] index_clubes = 0 # Agregamos esta línea para definir la variable indiceInverso = auxT - 2 for 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: # Sería 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)

R

# Imprimir horario Berger. # Jugadores desiguales, incluido uno mismo. # Conteo de reloj basado en cero modulo n. modn <- 7 stopifnot(modn %% 2 == 1) venues <- seq(from=0, length.out=(modn + 1) / 2) step <- length(venues) stopifnot((modn %% step) != 0) # Crear primera ronda, diagonal == (0 %% n). # Dos jugadores por sede (en casa y fuera). round <- rep(0, length(venues) * 2) round[c(TRUE, FALSE)] <- +venues round[c(FALSE, TRUE)] <- -venues %% modn for (r in seq_len(modn)){  cat(sprintf("Round %2d:", r))  # Imprimir sedes.  for (v in venues) {  # Reemplazar self por jugador añadido (n) en el primer sitio.  # 1-indexación en la impresión.  v0 <- round[v * 2 + 1:2]  if (v == 0) v0[((r %% 2)) + 1] <- modn  cat(sprintf("%2d - %2d ", v0[1] + 1, v0[2] + 1))  }  cat('\n')    # Ciclo a la siguiente diagonal.  round <- (round + step) %% modn  }

R

Sistema Rutch-Berger. ^[3]

# Imprimir horario Rutch-Berger. modn <- 11 # Número de jugadores, excepto el pivote. stopifnot(modn %% 2 == 1) # Impar. round <- LETTERS[1:modn] # Nombre de los jugadores. half <- (modn + 1) / 2 # Primer tiempo vs. segundo tiempo + pivote step <- 1 # Mover una posición a la derecha. for (r in seq(modn)){  cat(sprintf("Ronda %-2d: ", r))  v0 <- c(round[1], "w")  if (r %% 2 == 0) v0 <- rev(v0)  cat(paste(c(v0[1], round[2:half]), c(v0[2], rev(tail(round, half - 1))), sep = "-"), "\n")  round <- c(tail(round, step), head(round, -step)) } # Ronda 1 : A-w B-K C-J D-I E-H F-G  # Ronda 2 : w-K A-J B-I C-H D-G E-F  # Ronda 3 : J-w K-I A-H B-G C-F D-E  # Ronda 4 : w-I J-H K-G A-F B-E C-D  # Ronda 5 : H-w I-G J-F K-E A-D B-C  # Ronda 6 : w-G H-F I-E J-D K-C A-B  # Ronda 7 : F-w G-E H-D I-C J-B K-A  # Ronda 8 : w-E F-D G-C H-B I-A J-K  # Ronda 9 : D-w E-C F-B G-A H-K I-J  # Ronda 10: w-C D-B E-A F-K G-J H-I  # Ronda 11: B-w C-A D-K E-J F-I G-H

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:

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.

Véase también

Portal:Deporte. Contenido relacionado con Deporte.

Referencias

Webster's Third New International Dictionary of the English Language, Unabridged (1971, G. & C. Merriam Co), p.1980.
Orcutt, William Dana (1895). Official Lawn Tennis Bulletin 2. New York: The Editors. pp. 1, 3.
Livre de l'arbitre 210 en el sitio web de la fr:Fédération française des échecs

Datos: Q841144

[Webster-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] Livre de l'arbitre 210 en el sitio web de la fr:Fédération française des échecs

[1]

[2]

[3]