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.
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:
- 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).
|
|
Algoritmos de selección
Si es el número de competidores, una ronda simple de este sistema requiere encuentros. Si es un número par, entonces en rondas, se pueden jugar partidos simultáneamente. Si es impar, habrá rondas con 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
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 numero de clubes
clubes = []15
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 False
if impar:
auxT += 1
totalP = auxT/2 # total de partidos de una jornada
jornada = []
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: # 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:
- 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.
- ↑ «UC Berkeley Quiz Bowl: How To Make Schedules». www.ocf.berkeley.edu. Consultado el 14 de septiembre de 2021.
| Control de autoridades |
|
|---|
Datos: Q841144