# Elo Rating Algorithm

• Difficulty Level : Medium
• Last Updated : 31 May, 2022

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

## Javascript

 ``

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 arrow_drop_up