Su tarea es calcular la probabilidad esperada de ganar para 2 jugadores en algún juego, cada uno con su propia calificación ELO . El jugador A tiene ELO R _a y el jugador B tiene ELO R _b

El puntaje esperado para el Jugador A (E _a ) es: 1 / (1 + 10 ^{(R _b - R _a ) / 400} ). Hay una ecuación similar para el jugador B (E _b ): 1 / (1 + 10 ^{(R _a - R _b ) / 400} ).

Si quieres una versión más copiable: 1 / (1 + 10^((a-b) / 400))

E _a + E _b debe ser igual a 1.

Por lo tanto, el puntaje para un jugador es su probabilidad esperada de ganar algún partido, en decimal.

Su programa / función debe tomar 2 entradas, ELO del jugador A y ELO del jugador B, e imprimir / devolver sus respectivas posibilidades de ganar en formato decimal. La salida debe sumar uno, y debe tener una precisión de al menos 5 decimales ( 0.00000). Después de 5 decimales, es posible que tenga dígitos inexactos, siempre que las dos salidas sigan sumando una.

Ejemplos:

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

En el caso de prueba final, algunas respuestas usan exponenciación científica para representar el valor. Esto no es valido.

Puede ver aquí en el caso de prueba 3 que 0.557312no es del todo exacto, porque 2debería ser un 1, pero esto está bien porque es después de cinco decimales y las salidas aún suman uno.

Este es un ejemplo de salida no válida:

9999 9998 -> 0.5014391117091516, 0.49856088829084844

Parece que satisface los requisitos a primera vista, pero los números se suman 1.00000000000000004y, por lo tanto, la salida no es válida.

Los ceros finales en la salida están bien.

Puede suponer que el ELO de un jugador siempre será mayor que 0, y nadie tendrá un ELO mayor que 9999.

El formato de entrada y salida es flexible, pero la entrada y la salida aún deben estar en la base 10.

Como se trata de código de golf , ¡la respuesta con el recuento de bytes más bajo ganará!

Jalea , 9 bytes

÷400⁵*÷S$

Pruébalo en línea! o Ver todos los casos de prueba.

La entrada es una matriz [Ra, Rb]y la salida es una matriz [Ea, Eb].

Explicación

÷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 bytes

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

-8 bytes gracias a @math_junkie

MATL, 11 bytes

10i400/^ts/

Toma la entrada como una lista y genera una lista.

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 bytes

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

Algunas otras soluciones de 23 bytes:

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

Pruébalo en línea!

Explicación

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 bytes

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

Define una macro parametrizada (bastante ingenua) M, el enfoque de trabajo más corto que se me ocurrió, pero probablemente aún no sea el más corto. Como tal, cualquier sugerencia de golf es muy apreciada.

De todos modos, esto devuelve 2 valores de coma flotante E_by E_a, respectivamente.

Pruébalo en línea!

JavaScript (ES7), 41 35 bytes

Guardado 6 bytes gracias a @Neil

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

Lenguaje de macros SAS, 70 bytes

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

La salida es un conjunto de datos SAS donde las variables py qlas posibilidades de los jugadores de ganar. Se pueden guardar 11 bytes eliminando el printprocedimiento.

C #, 92 bytes

No es el más corto, pero es C #, nunca el más corto.

Golfed

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

Sin 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 bytes

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

Ejemplo

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