The Wilson Interval skor adalah interval kepercayaan dari probabilitas keberhasilan, berdasarkan proporsi keberhasilan dalam satu set percobaan Bernoulli (percobaan Bernoulli adalah percobaan di mana tepatnya dua hasil yang mungkin: keberhasilan atau kegagalan ). Interval diberikan oleh rumus berikut:

Dua nilai yang diberikan oleh rumus adalah batas atas dan bawah dari interval. n _S dan n _F adalah jumlah keberhasilan dan kegagalan, masing-masing, dan n adalah jumlah total percobaan (setara dengan n _S + n _F ). z adalah parameter yang tergantung pada tingkat kepercayaan yang diinginkan. Untuk keperluan tantangan ini, z = 1,96 akan digunakan (sesuai dengan interval kepercayaan 95%) ¹ .

Dengan bilangan bulat non-negatif n _S dan n _F , mengeluarkan batas interval skor Wilson.

Aturan

• Keluaran harus seakurat mungkin dengan nilai yang sebenarnya, dalam batas-batas implementasi floating-point bahasa Anda, mengabaikan masalah potensial apa pun karena ketidakakuratan aritmatika titik-mengambang. Jika bahasa Anda mampu aritmatika presisi sewenang-wenang, bahasa itu harus setidaknya setepat aritmetika presisi ganda IEEE 754.
• Input akan berada dalam kisaran yang dapat diwakili untuk tipe integer asli bahasa Anda, dan output akan berada dalam kisaran yang dapat diwakili untuk tipe floating-point asli bahasa Anda.
• n akan selalu positif.
• Urutan output tidak masalah.

Uji Kasus

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. The znilai adalah 1-α/2kuantil th dari distribusi normal standar, di mana αadalah tingkat signifikansi. Jika Anda menginginkan interval kepercayaan 95%, tingkat signifikansi Anda adalah α=0.05, dan znilainya 1.96.

Mathematica, 48 byte (pengkodean UTF-8)

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

Fungsi yang tidak disebutkan namanya mengambil dua argumen dalam urutan n_s, n_fdan mengembalikan pasangan bilangan real yang dipesan. Simbol tiga byte √, yang mewakili fungsi akar kuadrat, adalah U-221A.

Menggunakan fakta bahwa diawali ##dengan angka menghasilkan produk dari dua argumen, sementara +##menghasilkan jumlah mereka. Juga menggunakan fakta bahwa produk dan jumlah secara otomatis merangkai daftar, sehingga {-1,1}√(...)menerapkan ± dalam rumus. Menentukan konstanta s = z^2alih-alih dengan zsendirinya juga menghemat beberapa byte. (Kebanyakan saya hanya bangga menyelamatkan satu byte dengan memperhatikan hal 1.4^4itu 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)}

Fungsi ini sebenarnya mengembalikan persimpangan-batas bawah dan atas; misalnya, jika dipanggil dengan argumen 100 dan 0, ia mengembalikan:

any(0.963005192523998, 1)

Ini adalah format output non-tradisional untuk sedikitnya, tetapi tidak ada format tertentu yang ditentukan, dan kedua nilai yang diperlukan ada.

05AB1E , 34 byte

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

Input berupa form. [n_s, n_f]
Output berupa form[upper, lower]

Cobalah online!

Penjelasan

"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

Pesona Rise , 105 byte

#StillBetterThanJava

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

Cobalah online!

Input berupa form. n_s n_f
Output berupa form lower upperdan memiliki spasi tambahan

Ya Tuhan yang ini berantakan. Ini versi yang belum dibuka:

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

Semua itu yuntuk memperlambat IP kedua sehingga tiba di Ttitik ransfer pada waktu yang tepat (yaitu kedua). Ini mendorong 3 item teratas dari satu pointer ke yang lain (setup untuk tindakan ini digambarkan di bawah). 'Ä1C,menghasilkan zdengan membagi karakter 196 dengan 100 (dup, persegi, dup, div 2, dup, div 2 ...). Yang lain-lain hanyalah sekelompok manipulasi matematika dan tumpukan untuk mendorong nilai masa depan ke tumpukan sampai mereka diperlukan. Sebagian besar, mereka berakhir dalam urutan yang benar dan hanya sampai r4s{++}kita harus membalikkan tumpukan dan memutar semuanya untuk mendapatkan nilai yang kita inginkan di samping satu sama lain di samping satu sama lain.

Mungkin ada ruang untuk perbaikan, tetapi cukup kompleks sehingga saya tidak bisa melihatnya. Heck, secara tidak sengaja membaca "z" bukannya "n" dalam rumus asli pada satu titik dan memperbaiki yang kasar.

Saya harus mengeluarkan kartu catatan dan mensimulasikan tumpukan untuk memastikan itu benar:

Setiap satu memiliki nilai pada kedua ujungnya karena berapa banyak variabel yang ada (mis. Saya akan punya satu dengan S dan satu dengan F, saya akan mem-pop keduanya, membalikkan sekitar dan menambahkan S + F yang ada di ujung yang lain ke atas tumpukan). Anda dapat melihat salah satu sqrt(...)kartu memiliki Sdi tepi bawah.

R , 58 53 51 49 41 byte

-15 byte, terima kasih kepada J.Doe. -2 byte terima kasih kepada 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

Input adalah array dua angka, di salah satu format: [25 75], [25, 75], [25; 75].

Cobalah online! atau verifikasi semua kasus uji .

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

Cobalah online!

APL (Dyalog Unicode) , 50 byte

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

Cobalah online!

$⍺←n_s$$⍵←n_f$

Terima kasih kepada H.PWiz dan dzaima karena telah membantu.

Bagaimana:

                                        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)

Output adalah bilangan bulat yang kompleks dengan interval yang disimpan sebagai bagian nyata / imajiner.

dc , 71 byte

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

Mengambil kedua input pada dua jalur terpisah pada saat pemanggilan, dan mengeluarkan pada dua baris terpisah dengan batas atas di bagian bawah dan batas bawah di atas .

Sebagai contoh:

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

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

Tidak Disatukan:

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

Pengujian:

(g 1 10)

Keluaran:

0.016231752262825982
0.3773646254862038

Java 7, 130 byte

Golf:

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

Tidak Disatukan:

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

Cobalah online

Mengembalikan array tipe double dengan panjang 2, mungkin bisa lebih banyak golf.

> <> dengan -vflag, 100 byte

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

Mengharapkan input akan hadir pada stack pada awal eksekusi, dalam urutan n_s, n_f. Cobalah online!

Apa bahasa yang bodoh untuk mencoba ini di ...

Karena> <> tidak memiliki operator eksponen atau root, akar kuadrat dihitung pada baris kedua kode menggunakan metode Babel , untuk akurasi 1e-8- untuk setiap contoh yang saya coba, ini akurat untuk setidaknya 10 tempat desimal. Jika ini tidak cukup tepat, batas dapat dikencangkan dengan menambahkan lebih banyak :*di baris kedua, mengacak hal-hal di sekitar untuk menjaga cermin di garis.

Output dalam bentuk berikut:

<lower bound>
<upper bound>

Pyth, 38 byte

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

Input adalah sebagai daftar nilai [n_s, n_f],. Keluaran adalah [upper, lower]Coba online di sini , atau verifikasi semua uji sekaligus di sini .

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)

Jelly , 30 byte

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

Cobalah online!

Penjelasan

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

Catatan

Beberapa fitur ini lebih baru daripada tantangannya. Saya percaya sekitar waktu tantangan ini diposting, ++®¶×÷++1.96²©HH¤×®½×-,1+®H¤+³÷çitu Jelly valid (32 byte), kurang ɗdan Ø-.

APL (NARS), 49 karakter, 98 byte

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

uji

  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