Ваше завдання - обчислити очікуваний шанс на перемогу для двох гравців у якійсь грі, кожен з яких має свій рейтинг ELO . У гравця A є ELO R _a, а у гравця B - ELO R _b

Очікуваний рахунок для гравця A (E _a ) становить: 1 / (1 + 10 ^{(R _b - R _a ) / 400} ). Існує аналогічне рівняння для гравця B (E _b ): 1 / (1 + 10 ^{(R _a - R _b ) / 400} ).

Якщо ви хочете скопіювати версію: 1 / (1 + 10^((a-b) / 400))

E _a + E _b має бути рівним 1.

Тому оцінка гравця - це їх очікуваний шанс виграти якийсь матч у десятковій кількості.

Ваша програма / функція повинна мати 2 входи, ELO гравця A та ELO гравця B та друкувати / повертати відповідний шанс на перемогу у десятковому форматі. Вихід повинен містити до одного, і ви повинні бути точними принаймні до 5 знаків після коми ( 0.00000). Через 5 знаків після коми може виникнути неточні цифри за умови, що два виходи все ще складають один.

Приклади:

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

У останньому тестовому випадку деякі відповіді використовують наукову експоненцію для відображення цінності. Це не вірно.

Тут ви можете бачити в тестовому випадку 3, що 0.557312не зовсім точно, тому що 2має бути a 1, але це добре, оскільки це після п'яти знаків після коми, а результати все ще складаються з одного.

Це приклад недійсного виводу:

9999 9998 -> 0.5014391117091516, 0.49856088829084844

Це виглядає так, що воно задовольняє вимогам на перший погляд, але цифри складаються 1.00000000000000004і тому висновок недійсний.

Останні нулі на виході добре.

Ви можете припустити, що коефіцієнт ELO гравця завжди буде більшим за 0, і ніхто не матиме ELO вище 9999.

Формат введення та виведення є гнучким, але вхід і вихід все одно повинні знаходитись у базовій частині 10.

Оскільки це код-гольф , відповідь з найменшим числом байтів виграє!

Желе , 9 байт

÷400⁵*÷S$

Спробуйте в Інтернеті! або Переглянути всі тестові випадки.

Вхід - це масив, [Ra, Rb]а вихід - масив [Ea, Eb].

Пояснення

÷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 байт

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

-8 байт завдяки @math_junkie

MATL, 11 байт

10i400/^ts/

Приймає введення як список і виводить список.

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 байти

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

Ще деякі 23-байтні рішення:

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

Спробуйте в Інтернеті!

Пояснення

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 байти

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

Визначає (досить наївний) параметризований макрос M, найкоротший робочий підхід, про який я міг би придумати, але, ймовірно, все ще не найкоротший. Таким чином, будь-які пропозиції щодо гольфу дуже вдячні.

У будь-якому випадку це повертає 2 значення з плаваючою комою, E_bі E_aвідповідно.

Спробуйте в Інтернеті!

JavaScript (ES7), 41 35 байт

Збережено 6 байт завдяки @Neil

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

Мова макросів SAS, 70 байт

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

Вихід - це набір даних SAS, де змінні pта qє шанси гравців на перемогу. Вилучивши процедуру, можна зберегти 11 байт print.

C #, 92 байти

Не найкоротший, але це C #, ніколи не найкоротший ..

Гольф

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

Безумовно

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

q, 26 байт

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

Приклад

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