Das Wilson-Bewertungsintervall ist ein Konfidenzintervall der Erfolgswahrscheinlichkeit, basierend auf dem Anteil der Erfolge in einer Reihe von Bernoulli-Studien (eine Bernoulli-Studie ist eine Studie, in der genau zwei Ergebnisse möglich sind: Erfolg oder Misserfolg ). Das Intervall ergibt sich aus der folgenden Formel:

Die beiden in der Formel angegebenen Werte sind die obere und untere Grenze des Intervalls. n _S und n _F sind die Anzahl der Erfolge bzw. Misserfolge, und n ist die Gesamtzahl der Versuche (äquivalent zu n _S + n _F ). z ist ein Parameter, der vom gewünschten Konfidenzniveau abhängt. Für die Zwecke dieser Herausforderung wird z = 1,96 verwendet (entsprechend einem 95% -Konfidenzintervall) ¹ .

Bei nicht negativen ganzen Zahlen n _S und n _F werden die Grenzen des Wilson-Bewertungsintervalls ausgegeben.

Regeln

• Die Ausgaben müssen innerhalb der Grenzen der Gleitkommaimplementierung Ihrer Sprache so genau wie möglich sein und mögliche Probleme aufgrund von arithmetischen Gleitkommaungenauigkeiten ignorieren. Wenn Ihre Sprache eine Arithmetik mit willkürlicher Genauigkeit unterstützt, muss sie mindestens so genau sein wie die IEEE 754-Arithmetik mit doppelter Genauigkeit.
• Die Eingaben liegen innerhalb des darstellbaren Bereichs für den systemeigenen Ganzzahltyp Ihrer Sprache und die Ausgaben liegen innerhalb des darstellbaren Bereichs für den systemeigenen Gleitkommatyp Ihrer Sprache.
• n wird immer positiv sein.
• Die Reihenfolge der Ausgänge spielt keine Rolle.

Testfälle

Format: n_s, n_f => lower, upper

0, 1 => 0.0, 0.7934567085261071
1, 0 => 0.20654329147389294, 1.0
1, 1 => 0.09452865480086611, 0.905471345199134
1, 10 => 0.016231752262825982, 0.3773646254862038
10, 1 => 0.6226353745137962, 0.9837682477371741
10, 90 => 0.05522854161313612, 0.1743673043676654
90, 10 => 0.8256326956323345, 0.9447714583868639
25, 75 => 0.17545094003724265, 0.3430464637007583
75, 25 => 0.6569535362992417, 0.8245490599627573
50, 50 => 0.40382982859014716, 0.5961701714098528
0, 100 => 0.0, 0.03699480747600191
100, 0 => 0.9630051925239981, 1.0

1. Der zWert ist das 1-α/2dritte Quantil der Standardnormalverteilung, wobei αes sich um das Signifikanzniveau handelt. Wenn Sie ein Konfidenzintervall von 95% wünschen, ist Ihr Signifikanzniveau α=0.05und der zWert ist 1.96.

Mathematica, 48 Bytes (UTF-8-Codierung)

({-1,1}√((s=1.4^4)##/+##+s^2/4)+#+s/2)/(s+##)&

Unbenannte Funktion, die zwei Argumente in der Reihenfolge verwendet n_s, n_fund ein geordnetes Paar reeller Zahlen zurückgibt. Das Drei-Byte-Symbol √, das die Quadratwurzelfunktion darstellt, ist U-221A.

Verwendet die Tatsache, dass das Voranstellen ##einer Zahl das Produkt der beiden Argumente +##ergibt , während sich deren Summe ergibt. Nutzt auch die Tatsache, dass Produkte und Summen automatisch über Listen laufen, so dass {-1,1}√(...)das ± in die Formel implementiert wird. Das Definieren der Konstante s = z^2anstelle von sich zselbst sparte auch ein paar Bytes. (Meistens bin ich nur stolz darauf, ein Byte zu speichern, indem ich merke, dass 1.4^4das genau ist 1.96^2!)

Perl 6 , 66 Bytes

->\s,\f,\z=1.96 {(s+(-z|z)*sqrt(s*f/(s+f)+z*z/4)+z*z/2)/(s+f+z*z)}

Diese Funktion gibt tatsächlich eine Oder-Verknüpfung der unteren und oberen Schranken zurück. Wenn es beispielsweise mit den Argumenten 100 und 0 aufgerufen wird, gibt es Folgendes zurück:

any(0.963005192523998, 1)

Es ist, gelinde gesagt, ein nicht traditionelles Ausgabeformat, aber es wurde kein bestimmtes Format angegeben, und beide erforderlichen Werte sind vorhanden.

05AB1E , 34 Bytes

"1.96"Dn©4/¹P¹O/+t*D()®;+¹0è+®¹O+/

Die Eingabe hat die Form Die [n_s, n_f]
Ausgabe hat die Form[upper, lower]

Probieren Sie es online!

Erläuterung

"1.96"                             # push 1.96
      Dn©                          # duplicate, square, store a copy in register
         4/                        # divide by 4
           ¹P¹O/                   # product of input divided by sum of input
                +                  # add this to (z^2)/4
                 t*                # sqrt and multiply with z
                   D()             # wrap in list together with a negated copy
                      ®;+          # add (z^2)/2
                         ¹0è+      # add n_s
                             ®¹O+/ # divide by z^2+n

Runenverzauberungen , 105 Bytes

#StillBetterThanJava

/:2,:2,i:3s:3s:i:3s*3s+::6s4s,+'qA{*:Z4s3TRr4s{++}\
\p2:,C1Ä'<> yyyyyyyyyyyyyyyyyyy'Ä1C,2p:2,//@S ',+ /

Probieren Sie es online!

Die Eingabe erfolgt in der Form Die n_s n_f
Ausgabe erfolgt in der Form lower upperund hat ein Leerzeichen am Ende

AH GOTT, das ist ein Durcheinander. Hier ist die entpackte Version:

>'Ä1C,:2p:2,:2,i:3s:3s:i:3s*3s+::6s4s,+'qA{*:Z4s3TRr4s{++}+,' S@
                  > yyyyyyyyyyyyyyyyyyy'Ä1C,2p:2,//

Alle diese ys sollen die zweite IP verlangsamen, damit sie Tzum richtigen Zeitpunkt (dh zur zweiten) am Übergabepunkt ankommt . Dadurch werden die drei obersten Elemente des einen Zeigers auf den anderen verschoben (das Setup für diese Aktion ist unten dargestellt). 'Ä1C,erzeugt zdurch Teilen des Zeichens 196 durch 100 (dup, square, dup, div 2, dup, div 2 ...). Alles andere ist nur ein Haufen mathematischer und Stapelmanipulationen, um zukünftige Werte in den Stapel zu verschieben, bis sie benötigt werden. Meistens enden sie in der richtigen Reihenfolge und es ist nur so lange, bis r4s{++}wir den Stapel umkehren und das Ganze drehen müssen, um die gewünschten Werte nebeneinander zu erhalten.

Es gibt wahrscheinlich Raum für Verbesserungen, aber es ist komplex genug, dass ich es nicht sehen kann. Heck, hatte gelesen versehentlich „z“ an Stelle von „n“ in der ursprünglichen Formel an einem Punkt und Fixierung , die rauh war.

Ich musste Notizkarten herausziehen und die Stapel simulieren, um sicherzustellen, dass es richtig war:

Jeder einzelne hat an beiden Enden einen Wert aufgrund der Anzahl der vorhandenen Variablen (z. B. ich hätte einen mit S und einen mit F, ich würde beide platzieren, einen umdrehen und das aktivierte S + F hinzufügen das andere Ende oben auf dem Stapel). Sie können sehen, dass eine der sqrt(...)Karten eine Sam unteren Rand hat.

R , 58 53 51 49 41 Bytes

-15 Bytes dank J.Doe. -2 Bytes dank Giuseppe.

function(x,y)prop.test(t(c(x,y)),cor=F)$c

MATL , 38 37 Bytes

pGs/1.96XJU4/XI+X^J*t_hIE+G1)+GsJU+/S

Eingang ist eine Anordnung von zwei Zahlen, in jedem dieser Formate: [25 75], [25, 75], [25; 75].

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Haskell , 70 69 68 67 Bytes

s#f|y<-1.96^2=[(s+y/2+k*sqrt(s*f*y/(s+f)+y^2/4))/(s+f+y)|k<-[-1,1]]

Probieren Sie es online!

APL (Dyalog Unicode) , 50 Byte

{(+/⍺⍵z)÷⍨(⍺+z÷2)(-,+).5*⍨z×(⍺×⍵÷⍺+⍵)+4÷⍨z←3.8416}

Probieren Sie es online!

$⍺←n_s$$⍵←n_f$ .

Vielen Dank an H.PWiz und dzaima für ihre Hilfe.

Wie:

                                        z←3.8416  ⍝ Set z=1.96²
                                     4÷⍨          ⍝ Divide it by 4
                                    +             ⍝ plus
                           (⍺×⍵÷⍺+⍵)             ⍝ (nf×ns)÷n
                         z×                       ⍝ ×z²
                     .5*⍨                         ⍝ to the power .5 (square root)
                (-,+)                             ⍝ ±
         (⍺+z÷2)                                  ⍝ ns+(z²/2)
(+/⍺⍵z)÷⍨                                        ⍝ all divided by nf+ns+z²

Python, 79 67 Bytes

lambda s,f,z=3.8416:2j**.5*(s-(-z*(f*s/(f+s)+z/4))**.5+z/2)/(f+s+z)

Die Ausgabe ist eine komplexe Ganzzahl mit dem als Real- / Imaginärteil gespeicherten Intervall.

dc , 71 Bytes

16k?dsa2*?sb1.96 2^dso+dlalb4**lalb+/lo+vlov*dsd+lalblo++2*dsx/rld-lx/f

Übernimmt beim Aufruf beide Eingaben in zwei separaten Zeilen und gibt sie in zwei separaten Zeilen aus, wobei die obere Grenze unten und die untere Grenze oben liegt .

Beispielsweise:

bash-4.4$ dc -e '16k?dsa2*?sb1.96 2^dso+dlalb4**lalb+/lo+vlov*dsd+lalblo++2*dsx/rld-lx/f'
10                # Input n_s
90                # Input n_f
.0552285416131361 # Output lower bound
.1743673043676654 # Output upper bound

Schläger 134 Bytes

(let*((n(+ s f))(z 1.96)(h(* z z))(p(/ 1(+ n h)))(q(+ s(/ h 2)))(r(* z(sqrt(+(/(* s f) n)(/ h 4))))))(values(* p(- q r))(* p(+ q r))))

Ungolfed:

(define (g s f)
  (let* ((n (+ s f))
         (z 1.96)
         (zq (* z z))
         (p (/ 1 (+ n zq)))
         (q (+ s (/ zq 2)))
         (r (* z (sqrt (+ (/(* s f) n) (/ zq 4))))))
    (values (* p (- q r)) (* p (+ q r)))))

Testen:

(g 1 10)

Ausgabe:

0.016231752262825982
0.3773646254862038

Java 7, 130 Bytes

Golf gespielt:

double[]w(int s,int f){double n=s+f,z=1.96,x=z*z,p=s+x/2,d=z*Math.sqrt(s*f/n+x/4),m=1/(n+x);return new double[]{m*(p-d),m*(p+d)};}

Ungolfed:

double[] w(int s, int f)
{
    double n = s + f, z = 1.96, x = z * z, p = s + x / 2, d = z * Math.sqrt(s * f / n + x / 4), m = 1 / (n + x);
    return new double[]
    { m * (p - d), m * (p + d) };
}

Probieren Sie es online aus

Gibt ein Array vom Typ double mit der Länge 2 zurück, das wahrscheinlich mehr golfen werden kann.

> <> mit -vFlag, 100 Bytes

:{:@:}*@+:@,24a,a,-:@:*:&4,+:\$~*{&:&2,+}:{:@@-{&+:&,nao+&,n;
,}:{::*@@-:0$0(?$-1a,:*:*:*(?\}:{:@,+2

Erwartet, dass die Eingabe beim Start der Ausführung in der angegebenen Reihenfolge auf dem Stapel vorhanden ist n_s, n_f.Probieren Sie es online!

Was für eine dumme Sprache, um dies in ...

Da es bei> <> keinen Exponenten oder Wurzeloperator gibt, wird die Quadratwurzel in der zweiten Codezeile nach der babylonischen Methode mit einer Genauigkeit von 1e-8mindestens 10 Dezimalstellen berechnet . Wenn dies nicht genau genug ist, können die Grenzen durch Hinzufügen von mehr verschärft werden:* in der zweiten Zeile , um die Spiegel in einer Linie zu halten.

Die Ausgabe erfolgt in der folgenden Form:

<lower bound>
<upper bound>

Pyth, 38 Bytes

J*K1.96Kmc++dhQcJ2+sQJ_B*K@+cJ4c*FQsQ2

Die Eingabe erfolgt als Liste von Werten [n_s, n_f]. Die Ausgabe ist [upper, lower]Online ausprobieren hier , oder überprüfen alle Testfälle auf einmal hier .

J*K1.96Kmc++dhQcJ2+sQJ_B*K@+cJ4c*FQsQ2   Implicit: Q=eval(input())

  K1.96                                  Set variable K=1.96 (z)
J*K    K                                 Set variable J=K*K (z^2)
                                *FQ      Product of input pair
                               c   sQ    Divide the above by the sum of the input pair
                            cJ4          J / 4
                           +             Add the two previous results
                          @          2   Take the square root of the above
                        *K               Multiply by K
                      _B                 Pair the above with itself, negated
        m                                Map each in the above, as d, using:
             hQ                            First value of input (i.e. n_s)
               cJ2                         J / 2
          ++d                              Sum the above two with d
         c                                 Divided by...
                  +sQJ                     ... (J + sum of input)

Gelee , 30 Bytes

×÷++1.96²©HH¤×®½×Ø-+®H¤+³÷++®ɗ

Probieren Sie es online!

Erläuterung

                   Inputs: s and f
×÷+                (s×f)÷(s+f)
    1.96²©HH¤      (© ← 1.96²)÷4      (call this W)

   +                         (s×f)÷(s+f)+W
             ×®             ((s×f)÷(s+f)+W)ש
               ½      sqrt[ ((s×f)÷(s+f)+W)ש ]   (call this R)

                ×Ø-            [   -R,      +R  ]
                   +®H¤        [©/2-R,   ©/2+R  ]
                       +³      [©/2-R+s, ©/2+R+s]

                         ÷           Divide both by:
                          ++®ɗ       (s+f)+©

Hinweis

Einige dieser Funktionen sind neuer als die Herausforderung. Ich glaube, um die Zeit, als diese Herausforderung veröffentlicht wurde, ++®¶×÷++1.96²©HH¤×®½×-,1+®H¤+³÷çwar gültiges Gelee (32 Bytes), fehlte ɗund Ø-.

APL (NARS), 49 Zeichen, 98 Byte

{k←1.9208⋄(2+n÷k)÷⍨(1+⍺÷k)+¯1 1×√1+2×⍺×⍵÷k×n←⍺+⍵}

Prüfung

  f←{k←1.9208⋄(2+n÷k)÷⍨(1+⍺÷k)+¯1 1×√1+2×⍺×⍵÷k×n←⍺+⍵}
  25 f 75
0.17545094 0.3430464637 
  0 f 1
0 0.7934567085 
  1 f 0
0.2065432915 1