Il tuo compito è calcolare la probabilità prevista di vincere per 2 giocatori in una partita, ognuno con il proprio punteggio ELO . Il giocatore A ha ELO R _a e il giocatore B ha ELO R _b

Il punteggio atteso per il giocatore A (E _a ) è: 1 / (1 + 10 ^{(R _b - R _a ) / 400} ). Esiste un'equazione simile per il giocatore B (E _b ): 1 / (1 + 10 ^{(R _a - R _b ) / 400} ).

Se vuoi una versione più copiabile: 1 / (1 + 10^((a-b) / 400))

E _a + E _b dovrebbe essere uguale a 1.

Pertanto, il punteggio per un giocatore è la probabilità prevista di vincere una partita, in decimale.

Il tuo programma / funzione dovrebbe prendere 2 input, l'ELO del giocatore A e l'ELO del giocatore B e stampare / restituire le rispettive possibilità di vincere in formato decimale. L'output deve aggiungere fino a uno ed è necessario essere precisi con almeno 5 cifre decimali ( 0.00000). Dopo 5 cifre decimali, potresti avere cifre imprecise, a condizione che le due uscite ne aggiungano ancora una.

Esempi:

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

Nel caso del test finale, alcune risposte usano l'espiazione scientifica per rappresentare il valore. Questo non è valido

Nel caso di test 3 puoi vedere che 0.557312non è del tutto esatto, perché 2dovrebbe essere un 1, ma va bene perché è dopo cinque cifre decimali e le uscite ne sommano ancora una.

Questo è un esempio di output non valido:

9999 9998 -> 0.5014391117091516, 0.49856088829084844

Sembra che soddisfi i requisiti a prima vista, ma i numeri si sommano 1.00000000000000004e quindi l'output non è valido.

Gli zero finali nell'output vanno bene.

Puoi presumere che l'ELO di un giocatore sarà sempre maggiore di 0 e nessuno avrà un ELO superiore a 9999.

Il formato di input e output è flessibile, ma input e output devono essere ancora nella base 10.

Dato che si tratta di code-golf , vincerà la risposta con il numero di byte più basso!

Gelatina , 9 byte

÷400⁵*÷S$

Provalo online! oppure Visualizza tutti i casi di test.

L'input è un array [Ra, Rb]e l'output è un array [Ea, Eb].

Spiegazione

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

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

-8 byte grazie a @math_junkie

MATL, 11 byte

10i400/^ts/

Prende l'input come elenco e genera un elenco.

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 byte

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

Alcune altre soluzioni a 23 byte:

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

Provalo online!

Spiegazione

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 byte

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

Definisce una macro con parametri (piuttosto ingenua) M , l'approccio di lavoro più breve a cui potrei pensare ma probabilmente non ancora il più breve. Come tale, tutti i suggerimenti per il golf sono molto apprezzati.

Comunque, questo restituisce 2 valori in virgola mobile E_be E_a, rispettivamente.

Provalo online!

JavaScript (ES7), 41 35 byte

6 byte salvati grazie a @Neil

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

SAS Macro Language, 70 byte

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

L'output è un set di dati SAS in cui le variabili pe qle possibilità dei giocatori di vincere. 11 byte possono essere salvati rimuovendo la printprocedura.

C #, 92 byte

Non il più corto, ma è C #, mai il più corto ..

golfed

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

Ungolfed

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

q, 26 byte

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

Esempio

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