ELO VĒRTĒŠANAS ALGORITMS

The Elo vērtēšanas algoritms ir plaši izmantots vērtēšanas algoritms, ko izmanto, lai sarindotu spēlētājus daudzās sacensību spēlēs.

Spēlētājiem ar augstākiem ELO reitingiem ir lielāka iespēja uzvarēt spēli nekā spēlētājiem ar zemākiem ELO reitingiem.
Pēc katras spēles tiek atjaunināts spēlētāju ELO reitings.
Ja spēlētājs ar augstāku ELO reitingu uzvar, no zemāk novērtētā spēlētāja tiek pārskaitīti tikai daži punkti.
Tomēr, ja uzvar zemāk novērtētais spēlētājs, tad no augstāk novērtētā spēlētāja pārskaitītie punkti ir daudz lielāki.

Pieeja: Lai atrisinātu problēmu, izpildiet šādu ideju:

P1: Spēlētāja ar reitingu2 iespējamība laimēt P2: iespēja uzvarēt spēlētājam ar reitingu1.
P1 = (1,0 / (1,0 + pow(10 ((vērtējums1 - vērtējums2) / 400))));
P2 = (1,0 / (1,0 + pow(10 ((vērtējums2 - vērtējums1) / 400))));

Acīmredzot P1 + P2 = 1. Spēlētāja reitings tiek atjaunināts, izmantojot tālāk norādīto formulu:-
vērtējums1 = vērtējums1 + K*(faktiskais rādītājs — paredzamais rezultāts);
Lielākajā daļā spēļu “Faktiskais rezultāts” ir 0 vai 1, kas nozīmē, ka spēlētājs uzvar vai zaudē. K ir konstante. Ja K vērtība ir mazāka, reitings tiek mainīts par nelielu daļu, bet, ja K vērtība ir lielāka, tad reitinga izmaiņas ir būtiskas. Dažādas organizācijas nosaka atšķirīgu K vērtību.

Piemērs:

Pieņemsim, ka vietnē chess.com notiek tiešraides spēle starp diviem spēlētājiem
vērtējums1 = 1200 reitings2 = 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
Un pieņemsim, ka konstante K=30;
CASE-1:
Pieņemsim, ka uzvar 1. spēlētājs: reitings1 = reitings1 + k*(faktiskais – paredzamais) = 1200+30(1 – 0,76) = 1207,2;
vērtējums2 = vērtējums2 + k*(faktiskais — paredzamais) = 1000+30(0 - 0,24) = 992,8;
2. gadījums:
Pieņemsim, ka uzvar 2. spēlētājs: reitings1 = reitings1 + k*(faktiskais — paredzamais) = 1200+30(0 - 0,76) = 1177,2;
vērtējums2 = vērtējums2 + k*(faktiskais — paredzamais) = 1000+30(1 - 0,24) = 1022,8;

Lai atrisinātu problēmu, veiciet tālāk norādītās darbības.

karte java

Aprēķiniet spēlētāju A un B uzvaras varbūtību, izmantojot iepriekš norādīto formulu
Ja uzvar spēlētājs A vai spēlētājs B, tad reitingi tiek attiecīgi atjaunināti, izmantojot formulas:
- vērtējums1 = vērtējums1 + K* (faktiskais rezultāts — paredzamais rezultāts)
- vērtējums2 = vērtējums2 + K* (faktiskais rezultāts — paredzamais rezultāts)
- Kur faktiskais rezultāts ir 0 vai 1
Izdrukājiet atjauninātos vērtējumus

Tālāk ir aprakstīta iepriekš minētās pieejas īstenošana.

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

Izvade

Updated Ratings:- Ra = 1207.21 Rb = 992.792

Laika sarežģītība: Algoritma laika sarežģītība galvenokārt ir atkarīga no pow funkcijas sarežģītības, kuras sarežģītība ir atkarīga no datora arhitektūras. Uz x86 šī ir pastāvīga laika darbība: -O(1)
Palīgtelpa: O(1)