Related Articles
Elo Rating Algorithm
• Last Updated : 20 Mar, 2018

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 ``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/

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up