Open In App

Elo Rating Algorithm

Improve
Improve
Like Article
Like
Save
Share
Report

The Elo Rating Algorithm is a widely used rating algorithm used to rank players in many competitive games. 

Players with higher ELO ratings have a higher probability of winning a game than a player with lower ELO ratings. After each game, the ELO rating of players is updated. If a player with a higher ELO rating wins, only a few points are transferred from the lower-rated player. However if the lower-rated player wins, then the transferred points from a higher-rated player are far greater.

Approach: To Solve the problem follow the below idea:

P1: Probability of winning of the player with rating2, P2: Probability of winning of the 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 the 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 the 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;

Follow the below steps to solve the problem:

  • Calculate the probability of winning of players A and B using the formula given above
  • If player A wins or player B wins then the ratings are updated accordingly using the formulas:
    • rating1 = rating1 + K*(Actual Score – Expected score)
    • rating2 = rating2 + K*(Actual Score – Expected score)
    • Where the Actual score is 0 or 1
  • Print the updated ratings

Below is the implementation of the above approach:

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;
}
 
// Driver code
int main()
{
    // Ra and Rb are current ELO ratings
    float Ra = 1200, Rb = 1000;
 
    int K = 30;
    bool d = 1;
 
    // Function call
    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




// 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);
}
 
console.log("Updated Ratings:-");
console.log(
    "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>


Output

Updated Ratings:-
Ra = 1207.21 Rb = 992.792

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



Last Updated : 25 Jan, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads