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 code-golf , la réponse avec le nombre d'octets le plus bas gagnera!

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))]

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

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

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

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!

JavaScript (ES7), 41 35 octets

6 octets enregistrés grâce à @Neil

a=>b=>[b=1/(1+10**((b-a)/400)),1-b]

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.

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

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