不同编程语言复现ELO匹配机制与机制原理理解

#include <bits/stdc++.h>
using namespace std;
void updateRatingUsingELoRating(float rating1, float rating2, int ratingConstant, bool player1SuccessProb) {
   float P1, P2;
   if(rating1 > rating2){
      P1 = (1.0 / (1.0 + pow(10.0, ((rating1 - rating2) / 400.0)) ) );
      P2 = 1 - P1;
   }
   else {
      P2 = (1.0 / (1.0 + pow(10.0, ((rating2 - rating1) / 400.0)) ) );
      P1 = 1 - P2;
   }
   if (player1SuccessProb == 1) {
      rating1 = rating1 + ratingConstant * (1 - P1);
      rating2 = rating2 + ratingConstant * (0 - P2);
   }
   else {
      rating1 = rating1 + ratingConstant * (0 - P1);
      rating1 = rating1 + ratingConstant * (1 - P2);
   }
   cout<<"Ratings After the game\n";
   cout<<"Player 1 : "<<rating1<<"\t Player 2 : "<<rating2;
}
int main()
{
   float rating1 = 782, rating2 = 1432;
   int ratingConstant = 100;
   bool player1SuccessProb = 1;
   cout<<"Ratings before the game: \n";
   cout<<"Player 1 : "<<rating1<<"\t Player 2 : "<<rating2<<endl;
   if(player1SuccessProb)
      cout<<"Player 1 wins the game!\n";
   else
      cout<<"Player 2 wins the game!\n";
   updateRatingUsingELoRating(rating1, rating2, ratingConstant, player1SuccessProb);
   return 0;
}

#include <iostream>
#include <cmath>
// Function to calculate the probability of winning for player A
float Probability(int ratingA, int ratingB) {
    return 1.0 / (1.0 + std::pow(10, (ratingB - ratingA) / 400.0));
}
// Function to update Elo ratings based on the outcome of the game
void EloRating(int& ratingA, int& ratingB, int K, int actualScoreA) {
    float expectedScoreA = Probability(ratingA, ratingB);
    float expectedScoreB = 1 - expectedScoreA;
    ratingA += K * (actualScoreA - expectedScoreA);
    ratingB += K * ((1 - actualScoreA) - expectedScoreB);
}
int main() {
    int ratingA = 1200;
    int ratingB = 1000;
    int K = 30;
    int actualScoreA = 1;
    EloRating(ratingA, ratingB, K, actualScoreA);
    std::cout << "Updated Ratings:\n";
    std::cout << "Player A: " << ratingA << "\n";
    std::cout << "Player B: " << ratingB << "\n";
    return 0;
}

#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;
}

Define the ELO rating system: The ELO rating system is a widely used algorithm to rank players in competitive games. It assigns players a skill level based on their performance in matches. The ELO rating is updated after each match based on the outcome and the expected probability of winning.
Calculate the expected probability of winning: Before a match, you need to calculate the expected probability of winning for each player. This can be done using the following formula:

public class EloMatchmaking {
    public static void main(String[] args) {
        int rating1 = 1200;
        int rating2 = 1000;
        int K = 30;
        double P1 = 1 / (1 + Math.pow(10, (rating2 - rating1) / 400));
        double P2 = 1 / (1 + Math.pow(10, (rating1 - rating2) / 400));
        // Suppose player 1 wins
        double actual = 1;
        double expected = P1;
        rating1 = (int) (rating1 + K * (actual - expected));
        rating2 = (int) (rating2 + K * (actual - expected));
        System.out.println("Updated ratings:");
        System.out.println("Player 1: " + rating1);
        System.out.println("Player 2: " + rating2);
    }
}

public class EloRating
{
    private const int K = 20;
    public static void UpdateEloRating(ref int rating1, ref int rating2, bool isFirstPlayerWin)
    {
        int delta = CalculateRatingChange(rating1, rating2, isFirstPlayerWin ? 1 : 0);
        rating1 += delta;
        rating2 -= delta;
    }
    private static int CalculateRatingChange(int rating1, int rating2, int actualScore)
    {
        double expectedScore = 1 / (1 + Math.Pow(10, (rating2 - rating1) / 400.0));
        return (int) (K * (actualScore - expectedScore));
    }
}