Elo Rating Algorithm

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.

Javascript

<script>
// 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);
  }

  document.write("Updated Ratings:-<br>");
  document.write(
    "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.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/