Khoảng điểm Wilson là khoảng tin cậy của xác suất thành công, dựa trên tỷ lệ thành công trong một loạt các thử nghiệm Bernoulli (một thử nghiệm Bernoulli là một thử nghiệm trong đó có hai kết quả chính xác: thành công hoặc thất bại ). Khoảng được đưa ra theo công thức sau:

Hai giá trị được đưa ra bởi công thức là giới hạn trên và dưới của khoảng. n _S và n _{F lần lượt} là số lần thành công và thất bại và n là tổng số thử nghiệm (tương đương với n _S + n _F ). z là một tham số phụ thuộc vào mức độ tin cậy mong muốn. Đối với mục đích của thử thách này, z = 1.96 sẽ được sử dụng (tương ứng với khoảng tin cậy 95%) ¹ .

Cho các số nguyên không âm n _S và n _F , xuất ra các giới hạn của khoảng điểm Wilson.

Quy tắc

• Các đầu ra phải chính xác nhất có thể với các giá trị thực, trong giới hạn triển khai điểm nổi của ngôn ngữ của bạn, bỏ qua mọi vấn đề tiềm ẩn do tính không chính xác của số học dấu phẩy động. Nếu ngôn ngữ của bạn có khả năng số học chính xác tùy ý, thì ít nhất nó phải chính xác như số học chính xác kép của IEEE 754.
• Các đầu vào sẽ nằm trong phạm vi có thể biểu thị cho loại số nguyên gốc của ngôn ngữ của bạn và các đầu ra sẽ nằm trong phạm vi có thể biểu thị cho loại dấu phẩy động gốc của ngôn ngữ của bạn.
• n sẽ luôn luôn tích cực.
• Thứ tự của đầu ra không quan trọng.

Các trường hợp thử nghiệm

Định dạng: 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. Các zgiá trị là 1-α/2quantile thứ của phân phối chuẩn chuẩn, trong đó αlà mức ý nghĩa. Nếu bạn muốn khoảng tin cậy 95%, mức ý nghĩa của bạn là α=0.05và zgiá trị là 1.96.

Mathicala, 48 byte (mã hóa UTF-8)

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

Hàm không tên lấy hai đối số theo thứ tự n_s, n_fvà trả về một cặp số thực có thứ tự. Ký hiệu ba byte √, đại diện cho hàm căn bậc hai, là U-221A.

Sử dụng thực tế là trước ##một số kết quả trong sản phẩm của hai đối số, trong khi +##kết quả là tổng của chúng. Cũng sử dụng thực tế là các sản phẩm và tổng sẽ tự động xâu chuỗi các danh sách, để {-1,1}√(...)thực hiện giá trị ± trong công thức. Xác định hằng số s = z^2thay vì zchính nó cũng lưu một vài byte. (Hầu hết tôi chỉ tự hào về việc tiết kiệm một byte bằng cách nhận ra điều đó 1.4^4là chính xác 1.96^2!)

Perl 6 , 66 byte

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

ví dụ: nếu được gọi với các đối số 100 và 0, nó sẽ trả về:

any(0.963005192523998, 1)

Đây là định dạng đầu ra phi truyền thống để nói rằng ít nhất, nhưng không có định dạng cụ thể nào được chỉ định và cả hai giá trị bắt buộc đều có mặt.

05AB1E , 34 byte

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

Đầu vào có dạng [n_s, n_f]
Đầu ra có dạng[upper, lower]

Hãy thử trực tuyến!

Giải trình

"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

Bùa mê , 105 byte

#StillBetterThanJava

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

Hãy thử trực tuyến!

Đầu vào có dạng n_s n_f
Đầu ra có dạng lower uppervà có khoảng trắng ở cuối

AH GOD đây là một mớ hỗn độn. Đây là phiên bản chưa mở:

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

Tất cả những thứ đó ylà làm chậm IP thứ hai để nó đến Tđiểm ransfer vào đúng thời điểm (tức là thứ hai). Thao tác này sẽ đẩy 3 mục trên cùng của một con trỏ sang bên kia (thiết lập cho hành động này được mô tả bên dưới). 'Ä1C,tạo zbằng cách chia ký tự 196 cho 100 (dup, vuông, dup, div 2, dup, div 2 ...). Mọi thứ khác chỉ là một loạt các thao tác toán học và ngăn xếp để đẩy các giá trị trong tương lai xuống ngăn xếp cho đến khi chúng cần thiết. Đối với hầu hết các phần, chúng kết thúc theo đúng thứ tự và chỉ đến khi r4s{++}chúng ta phải đảo ngược ngăn xếp và xoay toàn bộ để có được các giá trị chúng ta muốn cạnh nhau.

Có lẽ có chỗ để cải thiện, nhưng nó đủ phức tạp để tôi không thể nhìn thấy nó. Heck, đã vô tình đọc "z" thay vì "n" trong công thức ban đầu tại một thời điểm và sửa lỗi đó là thô.

Tôi đã phải rút ra các thông báo và mô phỏng các ngăn xếp để đảm bảo nó chính xác:

Mỗi một biến có một giá trị ở cả hai đầu do có bao nhiêu biến số (ví dụ: Tôi có một biến có S và một biến có F, tôi bật cả hai, lật một vòng và thêm S + F đã bật đầu kia đến đỉnh của ngăn xếp). Bạn có thể thấy một trong những sqrt(...)thẻ có Scạnh trên.

R , 58 53 51 49 41 byte

-15 byte nhờ J.Doe. -2 byte nhờ Giuseppe.

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

MATL , 38 37 byte

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

Đầu vào là một mảng của hai số, trong bất kỳ các định dạng: [25 75], [25, 75], [25; 75].

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Haskell , 70 69 68 67 byte

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

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 50 byte

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

Hãy thử trực tuyến!

$⍺←n_s$$⍵←n_f$ .

Cảm ơn H.PWiz và dzaima đã giúp đỡ.

Làm sao:

                                        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 byte

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

Đầu ra là một số nguyên phức tạp với khoảng thời gian được lưu trữ dưới dạng phần thực / ảo.

dc , 71 byte

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

Thực hiện cả hai đầu vào trên hai dòng riêng biệt khi gọi và đầu ra trên hai dòng riêng biệt với giới hạn trên ở dưới và giới hạn dưới ở trên .

Ví dụ:

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

Vợt 134 byte

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

Ung dung:

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

Kiểm tra:

(g 1 10)

Đầu ra:

0.016231752262825982
0.3773646254862038

Java 7, 130 byte

Chơi gôn

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

Ung dung:

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

Dùng thử trực tuyến

Trả về một mảng loại gấp đôi chiều dài 2, có thể được đánh gôn nhiều hơn.

> <> với -vcờ, 100 byte

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

Dự kiến ​​đầu vào sẽ có mặt trên ngăn xếp khi bắt đầu thực hiện, theo thứ tự n_s, n_f. Hãy thử trực tuyến!

Thật là một ngôn ngữ ngu ngốc để thử điều này trong ...

Vì> <> thiếu toán tử gốc hoặc toán tử gốc, căn bậc hai được tính trong dòng mã thứ hai bằng phương pháp Babylon , với độ chính xác 1e-8- đối với mọi ví dụ tôi đã thử, điều này chính xác đến ít nhất 10 chữ số thập phân. Nếu điều này không đủ chính xác, các giới hạn có thể được thắt chặt bằng cách thêm nhiều hơn :*vào dòng thứ hai, xáo trộn mọi thứ xung quanh để giữ cho các gương thẳng hàng.

Đầu ra có dạng sau:

<lower bound>
<upper bound>

Bình thường, 38 byte

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

Đầu vào là một danh sách các giá trị , [n_s, n_f]. Đầu ra là [upper, lower]Dùng thử trực tuyến tại đây hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc tại đây .

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)

Thạch , 30 byte

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

Hãy thử trực tuyến!

Giải trình

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

Ghi chú

Một số tính năng này mới hơn so với thử thách. Tôi tin rằng khoảng thời gian thử thách này được đăng, ++®¶×÷++1.96²©HH¤×®½×-,1+®H¤+³÷çlà Jelly hợp lệ (32 byte), thiếu ɗvà Ø-.

APL (NARS), 49 ký tự, 98 byte

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

kiểm tra

  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