Calcule el puntaje esperado de la calificación ELO

11

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 , ¡la respuesta con el recuento de bytes más bajo ganará!

Okx
fuente
1
+1 para la calificación ELO, a pesar de que me decepcionó descubrir que estás hablando de algo llamado calificación Elo.
Darren Ringer
También debe agregar el caso de prueba para el [9999, 998]que la mayoría de las respuestas parecen fallar.
Emigna
@Emigna agregó, pero lo hizo más extremo;)
Okx
@ Ok: Bien. Necesito volver al tablero de dibujo para manejar eso :)
Emigna
Parece que todas las respuestas fallan al 9999, 1incluir la mía, por lo que no puedo publicarlo :-(
Metoniem

Respuestas:

5

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))]
millas
fuente
@Okx Esa es la notación científica. Estoy seguro de que sabe lo que es, ya que acaba de editar el desafío de exigir la notación estándar después de que originalmente dijera que el formato de entrada / salida dependía de nosotros.
millas
¿Viste la otra salida? ¡Es 1.0!
Okx
3

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

Trelzevir
fuente
¿Por qué no usar una para la comprensión:1/(1+10**(x/400))for x in [b-a,a-b]
matemáticas drogadicto de
@math_junkie Se llama " comprensión de lista "
mbomb007
3

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
B. Mehta
fuente
1

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
Gato de negocios
fuente
Falla en 9999, 1:(
Metoniem
@Metoniem Eso es extraño ... definitivamente tiene algo que ver con problemas de redondeo, o tal vez algo así como cómo 0.1 + 0.2 = 0.30000000000000004. Lo investigaré
Business Cat
ahora se ve bien, TODAS las respuestas, incluida la calculadora de Google, devuelven el mismo resultado que su código. Estoy bastante seguro de que el caso de prueba no es válido :(
Metoniem
1

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!

R. Kap
fuente
No funciona9999, 1
Metoniem
@Metoniem Sí. Lo más probable es que tenga que ver con la forma en que C redondea los flotadores. : / Lo estoy investigando.
R. Kap
En realidad parece ser correcto, el caso de prueba puede ser inválido :(
Metoniem
1

JavaScript (ES7), 41 35 bytes

Guardado 6 bytes gracias a @Neil

a=>b=>[b=1/(1+10**((b-a)/400)),1-b]
ETHproductions
fuente
Como Ea + Eb = 1, solo escribe a=>b=>[b=1/(1+10**((b-a)/400)),1-b].
Neil
@Neil ¿En serio? Soy tan miope: P ¡Gracias!
ETHproductions
0

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.

J_Lard
fuente
0

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};
}
Metoniem
fuente
0

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
skeevey
fuente