ALGORITMUL DE EVALUARE ELO

The Algoritmul de evaluare Elo este un algoritm de evaluare utilizat pe scară largă pentru a clasifica jucătorii în multe jocuri competitive.

Jucătorii cu evaluări ELO mai mari au o probabilitate mai mare de a câștiga un joc decât jucătorii cu evaluări ELO mai mici.
După fiecare joc, ratingul ELO al jucătorilor este actualizat.
Dacă un jucător cu un rating ELO mai mare câștigă, doar câteva puncte sunt transferate de la jucătorul cu un rating mai scăzut.
Totuși, dacă jucătorul cu cota mai mică câștigă, atunci punctele transferate de la un jucător cu cota mai mare sunt mult mai mari.

Abordare: Pentru a rezolva problema urmați ideea de mai jos:

șir în numere întregi

P1: Probabilitatea de câștig a jucătorului cu rating2 P2: Probabilitatea de câștig a jucătorului cu rating1.
P1 = (1,0 / (1,0 + pow(10 ((evaluare1 - evaluare2) / 400))));
P2 = (1,0 / (1,0 + pow(10 ((evaluare2 - rating1) / 400))));

Evident P1 + P2 = 1. Evaluarea jucătorului este actualizată folosind formula de mai jos:-
rating1 = rating1 + K*(Scor real - Scor așteptat);
În majoritatea jocurilor, „Scorul real” este fie 0, fie 1 înseamnă că jucătorul fie câștigă, fie pierde. K este o constantă. Dacă K este de o valoare mai mică, atunci ratingul este modificat cu o mică fracțiune, dar dacă K este de o valoare mai mare, atunci modificările în rating sunt semnificative. Diferite organizații stabilesc o valoare diferită pentru K.

Exemplu:

Să presupunem că există un meci live pe chess.com între doi jucători
rating1 = 1200 rating2 = 1000;
mysql update join
P1 = (1,0 / (1,0 + pow(10 ((1000-1200) / 400)))) = 0,76
P2 = (1,0 / (1,0 + pow(10 ((1200-1000) / 400)))) = 0,24
Și să presupunem constanta K=30;
CAZ-1:
Să presupunem că jucătorul 1 câștigă: rating1 = rating1 + k*(real - așteptat) = 1200+30(1 - 0.76) = 1207.2;
rating2 = rating2 + k*(real - așteptat) = 1000+30(0 - 0,24) = 992,8;
Cazul-2:
Să presupunem că jucătorul 2 câștigă: rating1 = rating1 + k*(real - așteptat) = 1200+30(0 - 0.76) = 1177.2;
rating2 = rating2 + k*(real - așteptat) = 1000+30(1 - 0,24) = 1022,8;

Urmați pașii de mai jos pentru a rezolva problema:

Calculați probabilitatea de câștig a jucătorilor A și B folosind formula dată mai sus
Dacă jucătorul A câștigă sau jucătorul B câștigă, evaluările sunt actualizate în consecință folosind formulele:
- rating1 = rating1 + K*(Scor real - Scor așteptat)
- rating2 = rating2 + K*(Scor real - Scor așteptat)
- Unde scorul real este 0 sau 1
Tipăriți evaluările actualizate

Mai jos este implementarea abordării de mai sus:

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

Ieșire

Updated Ratings:- Ra = 1207.21 Rb = 992.792

Complexitatea timpului: Complexitatea temporală a algoritmului depinde în mare măsură de complexitatea funcției pow a cărei complexitate depinde de arhitectura computerului. Pe x86, aceasta este o operație în timp constant:-O(1)
Spațiu auxiliar: O(1)