Göreviniz, her biri kendi ELO Derecelendirmesine sahip bazı oyunlarda 2 oyuncu için beklenen kazanma şansını hesaplamaktır . A oyuncusu ELO R _a ve B oyuncusu ELO R _b

Oyuncu A (E beklenen mı _a ) aşağıdaki gibidir: 1 / (1 + 10 ^{(R, _B - Ar _bir ) / 400} ). Oyuncu B (E için de benzer bir denklem vardır _b (1 + 10: 1 /) ^{(R ' _bir - R' _b ) / 400} ).

Daha kopyalanabilir bir sürüm istiyorsanız: 1 / (1 + 10^((a-b) / 400))

E _{, bir} + E _b 1 'e eşit olması gerekir.

Bu nedenle, bir oyuncunun puanı, ondalık olarak bir maç kazanma şanslarıdır.

Programınız / işleviniz Oyuncu A'nın ELO'su ve Oyuncu B'nin ELO'su olmak üzere 2 giriş almalı ve ondalık biçimde kazanma şanslarını yazdırmalı / döndürmelidir. Çıkış olmalı birine kadar ekleyin ve en az 5 ondalık basamağa doğru olmalıdır ( 0.00000). 5 ondalık basamaktan sonra, iki çıkışın hala bir taneye kadar toplaması şartıyla, yanlış basamaklara sahip olabilirsiniz.

Örnekler:

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

Son test durumunda, bazı cevaplar değeri temsil etmek için bilimsel üs alma kullanır. Bu geçerli değil.

Burada test durumu 3'te 0.557312oldukça doğru olmadığını görebilirsiniz, çünkü 2a olmalı 1, ancak bu iyi çünkü beş ondalık basamaktan sonra ve çıkışlar hala bir tane ekliyor.

Bu geçersiz çıktıya bir örnektir:

9999 9998 -> 0.5014391117091516, 0.49856088829084844

Bu, ilk bakışta gereksinimleri karşılar gibi görünüyor, ancak sayılar toplanıyor 1.00000000000000004ve bu nedenle çıktı geçerli değil.

Çıktıdaki sondaki sıfırlar iyi.

Bir oyuncunun ELO'sunun daima 0'dan büyük olacağını ve hiç kimsenin 9999'dan daha yüksek bir ELO'su olmayacağını varsayabilirsiniz.

Giriş ve çıkış formatı esnektir, ancak giriş ve çıkış yine de taban 10'da olmalıdır.

Bu kod golf olduğundan , en düşük bayt sayısına sahip cevap kazanacaktır!

Jöle , 9 bayt

÷400⁵*÷S$

Çevrimiçi deneyin! veya Tüm test senaryolarını görüntüleyin.

Girdi bir dizi [Ra, Rb]ve çıktı bir dizidir [Ea, Eb].

açıklama

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

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

-8 bytes teşekkürler @math_junkie

MATL, 11 bayt

10i400/^ts/

Girişi liste olarak alır ve bir liste çıkarır.

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 bayt

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

Diğer 23 baytlık çözümler:

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

Çevrimiçi deneyin!

açıklama

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 bayt

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

(Oldukça saf) parametreli bir makro tanımlar M , aklıma gelen en kısa çalışma yaklaşımı, ama yine de en kısa değil. Bu nedenle, herhangi bir golf önerisi büyük beğeni topluyor.

Her neyse, bu sırasıyla 2 kayan nokta değeri döndürür E_bve E_a.

Çevrimiçi deneyin!

JavaScript (ES7), 41 35 bayt

@Neil sayesinde 6 bayt kaydedildi

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

SAS Makro Dili, 70 bayt

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

Çıktı, değişkenlerin pve qoyuncuların kazanma şansının olduğu SAS veri kümesidir . printProsedür kaldırılarak 11 bayt kaydedilebilir .

C #, 92 bayt

En kısa değil, ama C #, asla en kısa değil.

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 bayt

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

Misal

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