Open In App
Related Articles

Elo Rating Algorithm

Improve Article
Improve
Save Article
Save
Like Article
Like

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)


Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Last Updated : 25 Jan, 2023
Like Article
Save Article
Similar Reads
Related Tutorials