El algoritmo de calificación Elo es un algoritmo de calificación ampliamente utilizado que se utiliza para clasificar a los jugadores en muchos juegos competitivos. Los jugadores con una calificación ELO más alta tienen una mayor probabilidad de ganar un juego que un jugador con una calificación ELO más baja. Después de cada juego, se actualiza la calificación ELO de los jugadores. Si gana un jugador con una calificación ELO más alta, solo se transfieren unos pocos puntos del jugador con una calificación más baja. Sin embargo, si gana un jugador de menor calificación, los puntos transferidos de un jugador de mayor calificación son mucho mayores.
Planteamiento: P1: Probabilidad de ganar del jugador con rating2 P2: Probabilidad de ganar del jugador con rating1. P1 = (1.0 / (1.0 + pow(10, ((calificación1 – calificación2) / 400)))); P2 = (1.0 / (1.0 + pow(10, ((calificación2 – calificación1) / 400)))); Obviamente, P1 + P2 = 1. La clasificación del jugador se actualiza utilizando la fórmula que se indica a continuación: – clasificación 1 = clasificación 1 + K* (puntuación real – puntuación esperada); En la mayoría de los juegos, el «Puntaje real» es 0 o 1, lo que significa que el jugador gana o pierde. K es una constante. Si K tiene un valor más bajo, la calificación cambia en una pequeña fracción, pero si K tiene un valor más alto, los cambios en la calificación son significativos. Diferentes organizaciones establecen un valor diferente de K.
Ejemplo:
Supongamos que hay una partida en vivo en chess.com entre dos jugadores rating1 = 1200, rating2 = 1000; P1 = (1,0 / (1,0 + potencia(10, ((1000-1200) / 400)))) = 0,76 P2 = (1,0 / (1,0 + potencia(10, ((1200-1000) / 400)))) = 0.24 Y suponga constante K=30; CASO-1: Suponga que el jugador 1 gana: rating1 = rating1 + k*(real – esperado) = 1200+30(1 – 0.76) = 1207.2; rating2 = rating2 + k*(real – esperado) = 1000+30(0 – 0.24) = 992.8; Caso 2: suponga que el jugador 2 gana: rating1 = rating1 + k*(real – esperado) = 1200+30(0 – 0.76) = 1177.2; rating2 = rating2 + k*(real – esperado) = 1000+30(1 – 0.24) = 1022.8;
CPP
// CPP program for Elo Rating
#include <bits/stdc++.h>
using namespace std;
// Function to calculate the Probability
float Probability(int rating1, int rating2)
{
return 1.0 * 1.0 / (1 + 1.0 *
pow(10, 1.0 * (rating1 - rating2) / 400));
}
// Function to calculate Elo rating
// K is a constant.
// d determines whether Player A wins or Player B.
void EloRating(float Ra, float Rb, int K, bool d)
{
// To calculate the Winning
// Probability of Player B
float Pb = Probability(Ra, Rb);
// To calculate the Winning
// Probability of Player A
float Pa = Probability(Rb, Ra);
// Case -1 When Player A wins
// Updating the Elo Ratings
if (d == 1) {
Ra = Ra + K * (1 - Pa);
Rb = Rb + K * (0 - Pb);
}
// Case -2 When Player B wins
// Updating the Elo Ratings
else {
Ra = Ra + K * (0 - Pa);
Rb = Rb + K * (1 - Pb);
}
cout << "Updated Ratings:-\n";
cout << "Ra = " << Ra << " Rb = " << Rb;
}
int main()
{
// Ra and Rb are current ELO ratings
float Ra = 1200, Rb = 1000;
int K = 30;
bool d = 1;
EloRating(Ra, Rb, K, d);
return 0;
}
Java
// Java program to count rotationally
// equivalent rectangles with n unit
// squares
class GFG {
// Function to calculate the Probability
static float Probability(float rating1,
float rating2)
{
return 1.0f * 1.0f / (1 + 1.0f *
(float)(Math.pow(10, 1.0f *
(rating1 - rating2) / 400)));
}
// Function to calculate Elo rating
// K is a constant.
// d determines whether Player A wins
// or Player B.
static void EloRating(float Ra, float Rb,
int K, boolean d)
{
// To calculate the Winning
// Probability of Player B
float Pb = Probability(Ra, Rb);
// To calculate the Winning
// Probability of Player A
float Pa = Probability(Rb, Ra);
// Case -1 When Player A wins
// Updating the Elo Ratings
if (d == true) {
Ra = Ra + K * (1 - Pa);
Rb = Rb + K * (0 - Pb);
}
// Case -2 When Player B wins
// Updating the Elo Ratings
else {
Ra = Ra + K * (0 - Pa);
Rb = Rb + K * (1 - Pb);
}
System.out.print("Updated Ratings:-\n");
System.out.print("Ra = " + (Math.round(
Ra * 1000000.0) / 1000000.0)
+ " Rb = " + Math.round(Rb
* 1000000.0) / 1000000.0);
}
//driver code
public static void main (String[] args)
{
// Ra and Rb are current ELO ratings
float Ra = 1200, Rb = 1000;
int K = 30;
boolean d = true;
EloRating(Ra, Rb, K, d);
}
}
// This code is contributed by Anant Agarwal.
Python3
# Python 3 program for Elo Rating
import math
# Function to calculate the Probability
def Probability(rating1, rating2):
return 1.0 * 1.0 / (1 + 1.0 * math.pow(10, 1.0 * (rating1 - rating2) / 400))
# Function to calculate Elo rating
# K is a constant.
# d determines whether
# Player A wins or Player B.
def EloRating(Ra, Rb, K, d):
# To calculate the Winning
# Probability of Player B
Pb = Probability(Ra, Rb)
# To calculate the Winning
# Probability of Player A
Pa = Probability(Rb, Ra)
# Case -1 When Player A wins
# Updating the Elo Ratings
if (d == 1) :
Ra = Ra + K * (1 - Pa)
Rb = Rb + K * (0 - Pb)
# Case -2 When Player B wins
# Updating the Elo Ratings
else :
Ra = Ra + K * (0 - Pa)
Rb = Rb + K * (1 - Pb)
print("Updated Ratings:-")
print("Ra =", round(Ra, 6)," Rb =", round(Rb, 6))
# Driver code
# Ra and Rb are current ELO ratings
Ra = 1200
Rb = 1000
K = 30
d = 1
EloRating(Ra, Rb, K, d)
# This code is contributed by
# Smitha Dinesh Semwal
C#
// C# program to count rotationally equivalent
// rectangles with n unit squares
using System;
class GFG {
// Function to calculate the Probability
static float Probability(float rating1,
float rating2)
{
return 1.0f * 1.0f / (1 + 1.0f *
(float)(Math.Pow(10, 1.0f *
(rating1 - rating2) / 400)));
}
// Function to calculate Elo rating
// K is a constant.
// d determines whether Player A wins or
// Player B.
static void EloRating(float Ra, float Rb,
int K, bool d)
{
// To calculate the Winning
// Probability of Player B
float Pb = Probability(Ra, Rb);
// To calculate the Winning
// Probability of Player A
float Pa = Probability(Rb, Ra);
// Case -1 When Player A wins
// Updating the Elo Ratings
if (d == true) {
Ra = Ra + K * (1 - Pa);
Rb = Rb + K * (0 - Pb);
}
// Case -2 When Player B wins
// Updating the Elo Ratings
else {
Ra = Ra + K * (0 - Pa);
Rb = Rb + K * (1 - Pb);
}
Console.Write("Updated Ratings:-\n");
Console.Write("Ra = " + (Math.Round(Ra
* 1000000.0) / 1000000.0)
+ " Rb = " + Math.Round(Rb
* 1000000.0) / 1000000.0);
}
//driver code
public static void Main()
{
// Ra and Rb are current ELO ratings
float Ra = 1200, Rb = 1000;
int K = 30;
bool d = true;
EloRating(Ra, Rb, K, d);
}
}
// This code is contributed by Anant Agarwal.
Javascript
<script>
// Javascript program for Elo Rating
// Function to calculate the Probability
function Probability(rating1, rating2) {
return (
(1.0 * 1.0) / (1 + 1.0 * Math.pow(10, (1.0 * (rating1 - rating2)) / 400))
);
}
// Function to calculate Elo rating
// K is a constant.
// d determines whether Player A wins
// or Player B.
function EloRating(Ra, Rb, K, d) {
// To calculate the Winning
// Probability of Player B
let Pb = Probability(Ra, Rb);
// To calculate the Winning
// Probability of Player A
let Pa = Probability(Rb, Ra);
// Case 1 When Player A wins
// Updating the Elo Ratings
if (d === true) {
Ra = Ra + K * (1 - Pa);
Rb = Rb + K * (0 - Pb);
}
// Case 2 When Player B wins
// Updating the Elo Ratings
else {
Ra = Ra + K * (0 - Pa);
Rb = Rb + K * (1 - Pb);
}
document.write("Updated Ratings:-<br>");
document.write(
"Ra = " +
Math.round(Ra * 1000000.0) / 1000000.0 +
" Rb = " +
Math.round(Rb * 1000000.0) / 1000000.0
);
}
// Ra and Rb are current ELO ratings
const Ra = 1200;
const Rb = 1000;
const K = 30;
const d = true;
EloRating(Ra, Rb, K, d);
// This code is contributed by Vishal Vilas Shinde.
</script>
Producción:
Updated Ratings:- Ra = 1207.207642 Rb = 992.792419
Complejidad del tiempo La complejidad del tiempo del algoritmo depende principalmente de la complejidad de la función pow, cuya complejidad depende de la arquitectura de la computadora. En x86, esta es una operación de tiempo constante:-O(1) Referencias http://www.gautamnarula.com/rating/
Publicación traducida automáticamente
Artículo escrito por gaurav _purohit y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA