Ihre Aufgabe ist es, die erwartete Gewinnchance für 2 Spieler in einem Spiel mit jeweils eigener ELO-Bewertung zu berechnen . Spieler A hat ELO R _a und Spieler B hat ELO R _b

Die erwartete Punktzahl für Spieler A (E _a ) beträgt: 1 / (1 + 10 ^{(R _b - R _a ) / 400} ). Für Spieler B (E _b ) gibt es eine ähnliche Gleichung : 1 / (1 + 10 ^{(R _a - R _b ) / 400} ).

Wenn Sie eine kopierbarere Version wünschen: 1 / (1 + 10^((a-b) / 400))

E _a + E _b sollte gleich 1 sein.

Daher ist die Punktzahl für einen Spieler die erwartete Chance, ein Match zu gewinnen, dezimal.

Ihr Programm / Ihre Funktion sollte zwei Eingaben annehmen, die ELO von Spieler A und die ELO von Spieler B, und die jeweilige Gewinnchance im Dezimalformat drucken / zurückgeben. Die Ausgabe muss sich zu eins addieren und Sie müssen auf mindestens 5 Dezimalstellen genau sein ( 0.00000). Nach 5 Dezimalstellen haben Sie möglicherweise ungenaue Ziffern, vorausgesetzt, die beiden Ausgänge ergeben immer noch eine.

Beispiele:

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

Im letzten Testfall verwenden einige Antworten wissenschaftliche Exponentiation, um den Wert darzustellen. Dies ist nicht gültig.

Sie können in Testfall 3 hier sehen, dass dies 0.557312nicht ganz genau ist, da das a 2sein sollte 1, aber dies ist in Ordnung, da es nach fünf Dezimalstellen liegt und die Ausgaben immer noch eins ergeben.

Dies ist ein Beispiel für eine ungültige Ausgabe:

9999 9998 -> 0.5014391117091516, 0.49856088829084844

Dies scheint auf den ersten Blick die Anforderungen zu erfüllen, aber die Zahlen summieren sich 1.00000000000000004und daher ist die Ausgabe ungültig.

Nachgestellte Nullen in der Ausgabe sind in Ordnung.

Sie können davon ausgehen, dass der ELO eines Spielers immer größer als 0 ist und niemand einen ELO von mehr als 9999 hat.

Das Eingabe- und Ausgabeformat ist flexibel, aber die Eingabe und Ausgabe muss sich noch in Basis 10 befinden.

Da dies Code-Golf ist , gewinnt die Antwort mit der niedrigsten Byteanzahl!

Gelee , 9 Bytes

÷400⁵*÷S$

Probieren Sie es online aus! oder Alle Testfälle anzeigen.

Die Eingabe ist ein Array [Ra, Rb]und die Ausgabe ist ein Array [Ea, Eb].

Erläuterung

÷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 dank @math_junkie

MATL, 11 Bytes

10i400/^ts/

Nimmt die Eingabe als Liste und gibt eine Liste aus.

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

Einige andere 23-Byte-Lösungen:

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

Probieren Sie es online aus!

Erläuterung

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.))

Definiert ein (eher naives) parametrisiertes Makro M, den kürzesten Arbeitsansatz, den ich mir vorstellen kann, aber wahrscheinlich immer noch nicht den kürzesten. Daher werden alle Golfvorschläge sehr geschätzt.

Wie auch immer, gibt diese 2 Gleitkommawerte, E_bund E_a, respectively.

Probieren Sie es online aus!

JavaScript (ES7), 41 35 Byte

6 Bytes dank @Neil gespeichert

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

SAS-Makrosprache, 70 Byte

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

Die Ausgabe ist ein SAS-Datensatz, in dem Variablen pund qdie Gewinnchance der Spieler angegeben sind. Durch Entfernen der printProzedur können 11 Bytes gespeichert werden.

C #, 92 Bytes

Nicht das kürzeste, aber es ist C #, niemals das kürzeste.

Golf gespielt

   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 Bytes

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

Beispiel

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