Elo Rating Algorithm - GeeksforGeeks

Elo Rating Algorithm is widely used rating algorithm that is used to rank players in many competitive games.
Players with higher ELO rating have a higher probability of winning a game than a player with lower ELO rating. After each game, ELO rating of players is updated. If a player with higher ELO rating wins, only a few points are transferred from the lower rated player. However if lower rated player wins, then transferred points from a higher rated player are far greater.

Approach:
P1: Probability of winning of player with rating2
P2: Probability of winning of player with rating1.

P1 = (1.0 / (1.0 + pow(10, ((rating1 – rating2) / 400))));
P2 = (1.0 / (1.0 + pow(10, ((rating2 – rating1) / 400))));
Obviously, P1 + P2 = 1.

The rating of player is updated using the formula given below :-

rating1 = rating1 + K*(Actual Score – Expected score);

In most of the games, “Actual Score” is either 0 or 1 means player either wins or loose. K is a constant. If K is of a lower value, then the rating is changed by a small fraction but if K is of a higher value, then the changes in the rating are significant. Different organizations set a different value of K.

Example:

Suppose there is a live match on chess.com between two players
rating1 = 1200, rating2 = 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

And Assume constant K=30;

CASE-1 : Suppose Player 1 wins:
rating1 = rating1 + k*(actual – expected) = 1200+30(1 – 0.76) = 1207.2;
rating2 = rating2 + k*(actual – expected) = 1000+30(0 – 0.24) = 992.8;

Case-2 : Suppose Player 2 wins:
rating1 = rating1 + k*(actual – expected) = 1200+30(0 – 0.76) = 1177.2;
rating2 = rating2 + k*(actual – expected) = 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. 

Output:


Updated Ratings:-
Ra = 1207.207642 Rb = 992.792419

Time Complexity
Time complexity of algorithm depends mostly on the complexity of pow function whose
complexity is dependent on Computer Architecture.
On x86, this is constant time operation:-O(1)

References
http://www.gautamnarula.com/rating/

My Personal Notes

CPP

Java

Python3

C#

Recommended Posts: