ALGORITMO DE CLASSIFICAÇÃO ELO

O Algoritmo de classificação Elo é um algoritmo de classificação amplamente utilizado para classificar jogadores em muitos jogos competitivos.

Jogadores com classificações ELO mais altas têm maior probabilidade de ganhar um jogo do que jogadores com classificações ELO mais baixas.
Após cada jogo, a classificação ELO dos jogadores é atualizada.
Se um jogador com uma classificação ELO mais alta vencer, apenas alguns pontos serão transferidos do jogador com classificação mais baixa.
No entanto, se o jogador com classificação mais baixa vencer, os pontos transferidos de um jogador com classificação mais alta serão muito maiores.

Abordagem: Para resolver o problema siga a ideia abaixo:

P1: Probabilidade de vitória do jogador com rating2 P2: Probabilidade de vitória do jogador com rating1.
P1 = (1,0 / (1,0 + pow(10 ((classificação1 - classificação2) / 400))));
P2 = (1,0 / (1,0 + pow(10 ((classificação2 - classificação1) / 400))));

Obviamente P1 + P2 = 1. A classificação do jogador é atualizada usando a fórmula abaixo: -
rating1 = rating1 + K*(Pontuação Real - Pontuação Esperada);
Na maioria dos jogos, a 'Pontuação Real' é 0 ou 1 significa que o jogador ganha ou perde. K é uma constante. Se K tiver um valor inferior, a classificação será alterada em uma pequena fração, mas se K tiver um valor mais alto, as alterações na classificação serão significativas. Diferentes organizações definem um valor diferente de K.

Exemplo:

Suponha que haja uma partida ao vivo no chess.com entre dois jogadores
classificação1 = 1200 classificação2 = 1000;
P1 = (1,0 / (1,0 + pow(10 ((1000-1200) / 400)))) = 0,76
P2 = (1,0 / (1,0 + pow(10 ((1200-1000) / 400)))) = 0,24
E suponha constante K = 30;
ciclo while java
CASO-1:
Suponha que o Jogador 1 ganhe: rating1 = rating1 + k*(real - esperado) = 1200+30(1 - 0,76) = 1207,2;
classificação2 = classificação2 + k*(real - esperado) = 1000+30(0 - 0,24) = 992,8;
Caso-2:
Suponha que o Jogador 2 ganhe: rating1 = rating1 + k*(real - esperado) = 1200+30(0 - 0,76) = 1177,2;
classificação2 = classificação2 + k*(real - esperado) = 1000+30(1 - 0,24) = 1022,8;

Siga as etapas abaixo para resolver o problema:

Calcule a probabilidade de vitória dos jogadores A e B usando a fórmula fornecida acima
Se o jogador A vencer ou o jogador B vencer, as classificações serão atualizadas de acordo usando as fórmulas:
- rating1 = rating1 + K*(Pontuação real - Pontuação esperada)
- rating2 = rating2 + K*(Pontuação real - Pontuação esperada)
- Onde a pontuação real é 0 ou 1
Imprimir as classificações atualizadas

Abaixo está a implementação da abordagem acima:

CPP

#include    using namespace std; // Function to calculate the Probability float Probability(int rating1 int rating2) {  // Calculate and return the expected score  return 1.0 / (1 + pow(10 (rating1 - rating2) / 400.0)); } // Function to calculate Elo rating // K is a constant. // outcome determines the outcome: 1 for Player A win 0 for Player B win 0.5 for draw. void EloRating(float Ra float Rb int K float outcome) {  // Calculate the Winning Probability of Player B  float Pb = Probability(Ra Rb);  // Calculate the Winning Probability of Player A  float Pa = Probability(Rb Ra);  // Update the Elo Ratings  Ra = Ra + K * (outcome - Pa);  Rb = Rb + K * ((1 - outcome) - Pb);  // Print updated ratings  cout << 'Updated Ratings:-n';  cout << 'Ra = ' << Ra << ' Rb = ' << Rb << endl; } // Driver code int main() {  // Current ELO ratings  float Ra = 1200 Rb = 1000;  // K is a constant  int K = 30;  // Outcome: 1 for Player A win 0 for Player B win 0.5 for draw  float outcome = 1;  // Function call  EloRating(Ra Rb K outcome);  return 0; }

Java

import java.lang.Math; public class EloRating {  // Function to calculate the Probability  public static double Probability(int rating1 int rating2) {  // Calculate and return the expected score  return 1.0 / (1 + Math.pow(10 (rating1 - rating2) / 400.0));  }  // Function to calculate Elo rating  // K is a constant.  // outcome determines the outcome: 1 for Player A win 0 for Player B win 0.5 for draw.  public static void EloRating(double Ra double Rb int K double outcome) {  // Calculate the Winning Probability of Player B  double Pb = Probability(Ra Rb);  // Calculate the Winning Probability of Player A  double Pa = Probability(Rb Ra);  // Update the Elo Ratings  Ra = Ra + K * (outcome - Pa);  Rb = Rb + K * ((1 - outcome) - Pb);  // Print updated ratings  System.out.println('Updated Ratings:-');  System.out.println('Ra = ' + Ra + ' Rb = ' + Rb);  }  public static void main(String[] args) {  // Current ELO ratings  double Ra = 1200 Rb = 1000;  // K is a constant  int K = 30;  // Outcome: 1 for Player A win 0 for Player B win 0.5 for draw  double outcome = 1;  // Function call  EloRating(Ra Rb K outcome);  } }

Python

import math # Function to calculate the Probability def probability(rating1 rating2): # Calculate and return the expected score return 1.0 / (1 + math.pow(10 (rating1 - rating2) / 400.0)) # Function to calculate Elo rating # K is a constant. # outcome determines the outcome: 1 for Player A win 0 for Player B win 0.5 for draw. def elo_rating(Ra Rb K outcome): # Calculate the Winning Probability of Player B Pb = probability(Ra Rb) # Calculate the Winning Probability of Player A Pa = probability(Rb Ra) # Update the Elo Ratings Ra = Ra + K * (outcome - Pa) Rb = Rb + K * ((1 - outcome) - Pb) # Print updated ratings print('Updated Ratings:-') print(f'Ra = {Ra} Rb = {Rb}') # Current ELO ratings Ra = 1200 Rb = 1000 # K is a constant K = 30 # Outcome: 1 for Player A win 0 for Player B win 0.5 for draw outcome = 1 # Function call elo_rating(Ra Rb K outcome)

using System; class EloRating {  // Function to calculate the Probability  public static double Probability(int rating1 int rating2)  {  // Calculate and return the expected score  return 1.0 / (1 + Math.Pow(10 (rating1 - rating2) / 400.0));  }  // Function to calculate Elo rating  // K is a constant.  // outcome determines the outcome: 1 for Player A win 0 for Player B win 0.5 for draw.  public static void CalculateEloRating(ref double Ra ref double Rb int K double outcome)  {  // Calculate the Winning Probability of Player B  double Pb = Probability((int)Ra (int)Rb);  // Calculate the Winning Probability of Player A  double Pa = Probability((int)Rb (int)Ra);  // Update the Elo Ratings  Ra = Ra + K * (outcome - Pa);  Rb = Rb + K * ((1 - outcome) - Pb);  }  static void Main()  {  // Current ELO ratings  double Ra = 1200 Rb = 1000;  // K is a constant  int K = 30;  // Outcome: 1 for Player A win 0 for Player B win 0.5 for draw  double outcome = 1;  // Function call  CalculateEloRating(ref Ra ref Rb K outcome);  // Print updated ratings  Console.WriteLine('Updated Ratings:-');  Console.WriteLine($'Ra = {Ra} Rb = {Rb}');  } }

JavaScript

// Function to calculate the Probability function probability(rating1 rating2) {  // Calculate and return the expected score  return 1 / (1 + Math.pow(10 (rating1 - rating2) / 400)); } // Function to calculate Elo rating // K is a constant. // outcome determines the outcome: 1 for Player A win 0 for Player B win 0.5 for draw. function eloRating(Ra Rb K outcome) {  // Calculate the Winning Probability of Player B  let Pb = probability(Ra Rb);  // Calculate the Winning Probability of Player A  let Pa = probability(Rb Ra);  // Update the Elo Ratings  Ra = Ra + K * (outcome - Pa);  Rb = Rb + K * ((1 - outcome) - Pb);  // Print updated ratings  console.log('Updated Ratings:-');  console.log(`Ra = ${Ra} Rb = ${Rb}`); } // Current ELO ratings let Ra = 1200 Rb = 1000; // K is a constant let K = 30; // Outcome: 1 for Player A win 0 for Player B win 0.5 for draw let outcome = 1; // Function call eloRating(Ra Rb K outcome);

Saída

Updated Ratings:- Ra = 1207.21 Rb = 992.792

Complexidade de tempo: A complexidade temporal do algoritmo depende principalmente da complexidade da função pow, cuja complexidade depende da Arquitetura do Computador. No x86 esta é uma operação em tempo constante: -O(1)
Espaço Auxiliar: O(1)