的威尔逊得分间隔是成功的概率的置信区间的基础上，成功的在一组伯努利试验的比例（一个伯努利试验是其中恰好两个结果是可能的试验：成功或失败）。该间隔由以下公式给出：

公式给出的两个值是间隔的上限和下限。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+##)&

未命名函数按顺序接受两个参数n_s, n_f并返回有序对的实数。√代表平方根功能的三字节符号为U-221A。

使用以下事实：数字前面##导致两个自变量的乘积，而两个变量+##之和。还使用乘积和总和自动遍历列表的事实，从而{-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，具有一个尾随空格

啊上帝，这真是一团糟。这是展开的版本：

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

所有这些y都将减慢第二个IP的速度，以使其T在正确的时间（即第二个）到达传输点。这会将一个指针的前3个项推到另一个上（此动作的设置如下图所示）。'Ä1C,产生z通过分割字符196由100（DUP，正方形，DUP，DIV 2，DUP，DIV 2 ...）。否则，一切都只是一堆数学和堆栈操作，以将将来的值推入堆栈，直到需要它们为止。在大多数情况下，它们以正确的顺序结束，并且只有在r4s{++}我们必须反转堆栈并旋转整个对象以获得彼此想要的值之前，它们才正确。

可能还有改进的余地，但是它的复杂性足以使我看不到。哎呀，无意中阅读在一个点上，并固定在原公式中的“Z”，而不是“N” 即是粗糙。

我必须拉出笔记卡并模拟堆栈，以确保它是正确的：

由于存在多个变量，每个单项在两端都有一个值（例如，我将一个带S，一个带F，我会同时弹出它们，四处翻转，然后加上S + F另一端到堆栈顶部）。您会看到其中一张sqrt(...)卡S的下边缘有一个。

[R ，58 53 51 49 41字节

-15个字节，感谢J.Doe。-2个字节，感谢Giuseppe。

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

输入是两个数字的数组，采用以下任何一种格式：[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}

在线尝试！

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

输出是一个复数整数，间隔存储为实部/虚部。

直流，71字节

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

调用时在两条单独的行上同时接受输入，并在两条单独的行上接受输出，其上限在底部，而下限在顶部。

例如：

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。在线尝试！

尝试这种愚蠢的语言...

由于> <>缺少指数运算符或根运算符，因此平方根是使用巴比伦方法在第二行代码中计算的，精度为1e-8-对于我尝试的每个示例，此精度至少精确到小数点后10位。如果不够精确，可以通过添加更多内容来限制范围:*在第二行中，重新整理周围的东西以使镜子保持对齐。

输出格式如下：

<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¤+³÷ç是有效的Jelly（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