Menú principal

WikipediaLa enciclopedia libre

Buscar en Wikipedia
Buscar
Crear una cuenta
Acceder

Herramientas personales
Contenidos ocultar
Inicio
Desventajas del método
Criterios de clasificación
Algoritmos de selección
Elaboración de fixture
Algoritmos de programación
Alternar subsección Algoritmos de programación
Fixture
PHP
Ruby
Python3
Tenis
Véase también
Referencias
Sistema de todos contra todos

Artículo
Discusión
Leer
Editar
Ver historial

Herramientas
Apariencia ocultar
Texto

Pequeño

Estándar

Grande
Anchura

Estándar

Ancho

Este artículo o sección tiene referencias, pero necesita más para complementar su
verificabilidad.
Busca fuentes: «Sistema de todos contra todos» – noticias · libros · académico ·
imágenes
Este aviso fue puesto el 14 de septiembre de 2021.
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).12 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
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
Si
n
{\displaystyle n} es el número de competidores, una ronda simple de este sistema
requiere
n
(
n
−
1
)
2
{\displaystyle {\begin{matrix}{\frac {n(n-1)}{2}}\end{matrix}}} encuentros. Si
n
{\displaystyle n} es un número par, entonces en
(
n
−
1
)
{\displaystyle (n-1)} rondas, se pueden jugar
n
2
{\displaystyle {\begin{matrix}{\frac {n}{2}}\end{matrix}}} partidos
simultáneamente. Si
n
{\displaystyle n} es impar, habrá
n
{\displaystyle n} rondas con
n
−
1
2
{\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 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)

{
[Link]("IDA");
 for (int i = 0; i < [Link]; i ++)
{
[Link]("Ronda " + (i + 1) + ": ");

for (int j = 0; j < rondas[i].length; j ++)

{
[Link](" " + (1 + rondas[i][j].local) + "-" + (1 +
rondas[i][j].visitante));
}

[Link]();
}

[Link]("VUELTA");

for (int i = 0; i < [Link]; i ++)

{
[Link]("Ronda " + (i + 1) + ": ");

for (int j = 0; j < rondas[i].length; j ++)

{
[Link](" " + (1 + rondas[i][j].visitante) + "-" + (1 +
rondas[i][j].local));
}

[Link]();
}
}

static public void main(String[] args)

{
[Link]("Liga con 10 equipos:");

mostrarPartidos(calcularLiga(10));

[Link]();

[Link]("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 = [Link]
[Link](1, last)
end

def number_of_rounds
@rounds ||= ([Link] - 2) + 1
end

def number_of_matches
@matches ||= ([Link] / 2)
end
end

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

clubs = ("A".."T").collect {|x| x}

rounds = [Link](clubs).rounds
print_rounds(rounds)
Python3
tope = 8

# Modificar el número de clubes

clubes = []
for i in range(1, tope + 1):
[Link]("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:
[Link](clubes[index_clubes])
else:
if (i + 1) % 2 == 0:
partido = [clubes[index_clubes], clubes[auxT - 1]]
else:
partido = [clubes[auxT - 1], clubes[index_clubes]]
[Link](" vs ".join(partido))
else:
partido = [clubes[index_clubes], clubes[indiceInverso]]
[Link](" vs ".join(partido))
indiceInverso -= 1
index_clubes += 1

list_equipos = {
'jornada': "Jornada Nro.: " + str(i),
'equipos': equipos
}
[Link](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
Ver el portal sobre Deporte 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.
Control de autoridades
Proyectos WikimediaWd Datos: Q841144Diccionarios y enciclopediasBritannica: url
Categorías: Terminología deportivaSistemas de competición
Esta página se editó por última vez el 31 jul 2024 a las 05:22.
El texto está disponible bajo la Licencia Creative Commons Atribución-
CompartirIgual 4.0; pueden aplicarse cláusulas adicionales. Al usar este sitio
aceptas nuestros términos de uso y nuestra política de privacidad.
Wikipedia® es una marca registrada de la Fundación Wikimedia, una organización sin
ánimo de lucro.
Política de privacidadAcerca de WikipediaLimitación de responsabilidadCódigo de
conductaDesarrolladoresEstadísticasDeclaración de cookiesVersión para
móvilesWikimedia FoundationPowered by MediaWiki