Calculer la note ELO Score attendu

11

Votre tâche consiste à calculer les chances de gagner pour 2 joueurs dans un jeu, chacun avec sa propre cote ELO . Le joueur A a ELO R a et le joueur B a ELO R b

Le score attendu pour le joueur A (E a ) est: 1 / (1 + 10 (R b - R a ) / 400 ). Il existe une équation similaire pour le joueur B (E b ): 1 / (1 + 10 (R a - R b ) / 400 ).

Si vous voulez une version plus copiable: 1 / (1 + 10^((a-b) / 400))

E a + E b doit être égal à 1.

Par conséquent, le score d'un joueur est sa chance attendue de gagner un match, en décimal.

Votre programme / fonction doit prendre 2 entrées, ELO du joueur A et ELO du joueur B, et imprimer / retourner leurs chances respectives de gagner au format décimal. La sortie doit s'additionner à un et vous devez être précis à au moins 5 décimales ( 0.00000). Après 5 décimales, vous pouvez avoir des chiffres inexacts, à condition que les deux sorties s'ajoutent toujours à une.

Exemples:

1200 2100 -> 0.005591967 0.994408033
1 1 -> 0.5 0.5
60 20 -> 0.557312 0.442688
9999 9998 -> 0.501439 0.498561
9999 1 -> 0.999999 0.000001

Dans le dernier cas de test, certaines réponses utilisent l'exponentiation scientifique pour représenter la valeur. Ce n'est pas valable.

Vous pouvez voir dans le cas de test 3 ici que ce 0.557312n'est pas tout à fait précis, car le 2devrait être un 1, mais c'est très bien car il est après cinq décimales et les sorties s'ajoutent toujours à un.

Ceci est un exemple de sortie non valide:

9999 9998 -> 0.5014391117091516, 0.49856088829084844

Il semble que cela satisfasse les exigences à première vue, mais les chiffres s'additionnent 1.00000000000000004et donc la sortie n'est pas valide.

La fin des zéros dans la sortie est correcte.

Vous pouvez supposer que l'ELO d'un joueur sera toujours supérieur à 0 et que personne n'aura un ELO supérieur à 9999.

Le format d'entrée et de sortie est flexible, mais l'entrée et la sortie doivent toujours être en base 10.

Comme il s'agit de , la réponse avec le nombre d'octets le plus bas gagnera!

Okx
la source
1
+1 pour la note ELO, même si j'ai été déçu de constater que vous parliez plutôt de la note Elo.
Darren Ringer
Vous devez également ajouter le cas de test pour [9999, 998]lequel la plupart des réponses semblent échouer.
Emigna
@Emigna a ajouté, mais l'a rendu plus extrême;)
Okx
@Okx: Nice. Besoin de retourner à la planche à dessin pour gérer celui-là :)
Emigna
Il semble que toutes les réponses échouent, 9999, 1y compris la mienne, donc je ne peux pas la poster :-(
Metoniem

Réponses:

5

Gelée , 9 octets

÷400⁵*÷S$

Essayez-le en ligne! ou Afficher tous les cas de test.

L'entrée est un tableau [Ra, Rb]et la sortie est un tableau [Ea, Eb].

Explication

÷400⁵*÷S$  Input: array [Ra, Rb]
÷400       Divide each by 400, makes [Ra/400, Rb/400]
    ⁵*     Raise 10 to that power, makes [10^(Ra/400), 10^(Rb/400)]
        $  Monadic chain operating on previous result
      ÷      Divide each by
       S     The sum of the whole
           Makes [10^(Ra/400)/(10^(Ra/400) + 10^(Rb/400)),
                  10^(Rb/400)/(10^(Ra/400) + 10^(Rb/400))]
               = [1/(1 + 10^((Rb-Ra)/400)), 1/(1 + 10^((Ra-Rb)/400))]
miles
la source
@Okx C'est de la notation scientifique. Je suis sûr que vous savez ce que c'est puisque vous venez d'éditer le défi d'exiger une notation standard après avoir dit à l'origine que le format d'entrée / sortie dépendait de nous.
miles
Avez-vous regardé l'autre sortie? C'est 1.0!
Okx
3

Python 3, 55 47 octets

lambda a,b:[1/(1+10**(x/400))for x in[b-a,a-b]]

-8 octets grâce à @math_junkie

Trelzevir
la source
Pourquoi ne pas utiliser un pour la compréhension:1/(1+10**(x/400))for x in [b-a,a-b]
accro aux mathématiques
@math_junkie Cela s'appelle une " compréhension de liste "
mbomb007
3

MATL, 11 octets

10i400/^ts/

Prend les entrées sous forme de liste et sort une liste.

10       % push number literal
i        % push input
400      % push number literal
/        % divide the list (by 400)
^        % power (10^list, element wise)
t        % duplicate the list
s        % sum the second one
/        % divide by the sum
         % (implicit) convert to string and display
B. Mehta
la source
1

CJam , 23 octets

XAq~_W%\.m400df/f#:)f/p

Quelques autres solutions de 23 octets:

q~_W%\.m400df{/A\#)W#}p
Aq~_W%\.m400df/f{#)W#}p

Essayez-le en ligne!

Explication

X                        Push 1
 A                       Push 10
  q~                     Push an eval the input, a list containing 2 numbers
    _W%                  Duplicate the list and reverse it
       \                 Swap top stack elements, so the order of answers matches the input
        .m               Vectorized subtraction: computes Ra - Rb and Rb - Ra
          400d           Push 400.0 (must be a double, otherwise / performs integer division)
              f/         Divide both values by 400
                f#       Raise 10 to the power of both numbers
                  :)     Increment both numbers
                    f/   Divide 1 by both numbers
                      p  Output the list nicely
Chat d'affaires
la source
Échoue le 9999, 1:(
Metoniem
@Metoniem C'est étrange ... cela a certainement quelque chose à voir avec les problèmes d'arrondi, ou peut-être quelque chose comme comment 0.1 + 0.2 = 0.30000000000000004. Je vais y jeter un œil
Business Cat
cela semble bien maintenant, TOUTES les réponses, y compris la calculatrice de Google, renvoient le même résultat que votre code. Je suis sûr que le cas de test n'est pas valide :(
Metoniem
1

C, 63 octets

#define M(a,b)1/(1+pow(10,(a-b)/400.)),1/(1+pow(10,(b-a)/400.))

Définit une macro paramétrée (plutôt naïve) M, l'approche de travail la plus courte à laquelle je pouvais penser mais probablement pas la plus courte. En tant que tel, toutes les suggestions de golf sont grandement appréciées.

Quoi qu'il en soit, cela renvoie respectivement 2 valeurs à virgule flottante E_bet E_a.

Essayez-le en ligne!

R. Kap
la source
Échoue9999, 1
Metoniem
@Metoniem Yup. Cela a probablement à voir avec la façon dont les tours C flottent. : / Je regarde dedans.
R. Kap
Il semble en fait être correct, le cas de test peut être invalide :(
Metoniem
1

JavaScript (ES7), 41 35 octets

6 octets enregistrés grâce à @Neil

a=>b=>[b=1/(1+10**((b-a)/400)),1-b]
ETHproductions
la source
Puisque Ea + Eb = 1, il suffit d'écrire a=>b=>[b=1/(1+10**((b-a)/400)),1-b].
Neil
@Neil vraiment? Je suis tellement myope: P Merci!
ETHproductions
0

SAS Macro Language, 70 octets

%macro e(a,b);data t;p=1/(1+10**((&b-&a)/400));q=1-p;proc print%mend;

La sortie est un ensemble de données SAS où les variables pet qsont les chances des joueurs de gagner. 11 octets peuvent être enregistrés en supprimant la printprocédure.

J_Lard
la source
0

C #, 92 octets

Pas le plus court, mais c'est C #, jamais le plus court ..

Golfé

   static double[]f(int a,double b){b=1/(1+System.Math.Pow(10,(a-b)/400d));return new[]{1-b,b};

Non golfé

static double[] f(int a, double b)
{
    b = 1/(1 + System.Math.Pow(10, (a - b)/400d));
    return new[] {1 - b, b};
}
Metoniem
la source
0

q, 26 octets

{1%1+10 xexp(y-x;x-y)%400}

Exemple

q){1%1+10 xexp(y-x;x-y)%400}[1200;2100]
0.0055919673088347735 0.99440803269116518
skeevey
la source