ウィルソンスコア間隔はベルヌーイ試験（：ベルヌーイの試験は、正確に2つの結果が可能である、裁判での集合における成功の割合に基づいて、成功確率の信頼区間である成功または失敗）。間隔は次の式で与えられます。

式によって与えられる2つの値は、間隔の上限と下限です。n _Sとn _Fはそれぞれ成功と失敗の数であり、nは試行の総数です（n _S + n _Fに相当）。zは、必要な信頼レベルに依存するパラメーターです。このチャレンジのために、z = 1.96が使用されます（95％の信頼区間に対応）¹。

非負の整数n _Sおよびn _Fを指定すると、ウィルソンスコア間隔の境界が出力されます。

ルール

• 出力は、浮動小数点演算の不正確さによる潜在的な問題を無視して、言語の浮動小数点実装の制限内で、真の値に対して可能な限り正確でなければなりません。ご使用の言語が任意精度の演算に対応している場合、少なくともIEEE 754の倍精度演算と同じ精度でなければなりません。
• 入力は言語のネイティブ整数型の表現可能な範囲内にあり、出力は言語のネイティブ浮動小数点型の表現可能な範囲内にあります。
• nは常に正です。
• 出力の順序は重要ではありません。

テストケース

フォーマット： 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. z値は、1-α/2標準正規分布の第分位α有意水準です。95％の信頼区間が必要な場合、有意水準はα=0.05で、z値は1.96です。

Mathematica、48バイト（UTF-8エンコード）

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

名前のない関数は、順番に2つの引数を取りn_s, n_f、実数の順序付きペアを返します。√平方根関数を表す3バイトのシンボルはU-221Aです。

##数字が先行するという事実は、2つの引数の積になり+##ますが、それらの合計になります。また、積と合計がリストに自動的にスレッド化されるという事実を使用するため{-1,1}√(...)、式で± を実装します。それ自体のs = z^2代わりに定数を定義するとz、数バイトも節約されました。（ほとんどの場合、1.4^4正確にそれを認識してバイトを節約できたことを誇りに思っています1.96^2！）

Perl 6、66バイト

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

この関数は、実際には下限と上限の論理和を返します。たとえば、引数100と0を指定して呼び出された場合、以下を返します。

any(0.963005192523998, 1)

控えめに言っても非伝統的な出力形式ですが、特定の形式は指定されておらず、必要な値が両方とも存在します。

05AB1E、34バイト

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

入力は次の形式です [n_s, n_f]
出力は形式です[upper, lower]

オンラインでお試しください！

説明

"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

ルーンのエンチャント、105バイト

#StillBetterThanJava

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

オンラインでお試しください！

入力は形式ですn_s n_f
出力は形式ですlower upperであり、末尾にスペースがあります

AH GODこれはめちゃくちゃです。ラップされていないバージョンは次のとおりです。

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

これらyはすべて、2番目のIPの速度を落としてT、適切な時間（つまり2番目）に転送ポイントに到着するようにします。これにより、1つのポインターの上位3項目が他のポインターに押し出されます（このアクションのセットアップを以下に示します）。文字196を100で除算して'Ä1C,生成zします（dup、square、dup、div 2、dup、div 2 ...）。その他すべては、将来の値が必要になるまでスタックの下に押し出すための数学とスタック操作の束にすぎません。ほとんどの場合、それらは正しい順序で終わり、r4s{++}、スタックを反転し、すべてを回転させて、必要な値を隣同士に取得する必要があります。

おそらく改善の余地はありますが、私には見えないほど複雑です。ヘック、ある時点で元の式の「n」ではなく「z」を誤って読んで修正していたラフであったが。

それが正しいことを確認するために、ノートカードを引き出してスタックをシミュレートする必要がありました。

すべての変数は、変数の数が原因で両端に値があります（たとえば、1つはSで、もう1つはFで、両方をポップし、1つを反転し、オンになっているS + Fを追加します）スタックの一番上にもう一方の端）。いずれかのsqrt(...)カードSの下端にあることがわかります。

R、58 53 51 49 41バイト

J.Doeのおかげで-15バイト。-ジュゼッペのおかげで2バイト。

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

MATL、38 37バイト

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

入力は、これらの形式のいずれかで、2つの数の配列であります：[25 75]、[25, 75]、[25; 75]。

オンラインでお試しください！または、すべてのテストケースを確認します。

Haskell、70 69 68 67バイト

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]]

オンラインでお試しください！

APL（Dyalog Unicode）、50バイト

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

オンラインでお試しください！

中置Dfn、取得 $⍺←n_s$ そして $⍵←n_f$。

手伝ってくれたH.PWizとdzaimaに感謝します。

どうやって：

                                        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バイト

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

出力は、実数部/虚数部として保存された間隔を持つ複素数整数です。

dc、71バイト

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

呼び出し時に2つの別々の行で両方の入力を受け取り、2つの別々の行で出力を取得します。 下に、下限はtopになります。

例えば：

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

ラケット134バイト

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

ゴルフをしていない：

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

テスト：

(g 1 10)

出力：

0.016231752262825982
0.3773646254862038

Java 7、130バイト

ゴルフ：

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)};}

ゴルフをしていない：

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) };
}

オンラインで試す

長さ2のdouble型の配列を返します。おそらくもっとゴルフができます。

> <>と-vフラグ、100のバイト

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

入力が実行開始時にスタック上に存在することを期待しますn_s, n_f。オンラインでお試しください！

これを試みるのはなんて馬鹿げた言語...

> <>は、指数またはルートオペレータを欠くように、平方根を使用して、コードの2行目に算出されるバビロニア方法の精度、1e-8-私が試したすべての、例えば、これは少なくとも10の小数点以下の精度です。これが十分に正確でない場合は、さらに追加することで境界を強化できます:*、2行目を、ミラーを整列させるために物事をシャッフルします。

出力は次の形式です。

<lower bound>
<upper bound>

Pyth、38バイト

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

入力は、値のリストとしてです[n_s, n_f]。出力はここ[upper, lower]でオンラインで試すか、ここですべてのテストケースを一度に確認します。

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)

ゼリー、30バイト

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

オンラインでお試しください！

説明

                   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)+©

注意

これらの機能の一部は、チャレンジよりも新しいものです。このチャレンジが投稿された頃、私++®¶×÷++1.96²©HH¤×®½×-,1+®H¤+³÷çは有効なジェリー（32バイト）であり、欠けていたɗと信じていますØ-。

APL（NARS）、49文字、98バイト

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

テスト

  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