ช่วงคะแนนวิลสันเป็นช่วงความเชื่อมั่นของความน่าจะเป็นของความสำเร็จขึ้นอยู่กับสัดส่วนของความสำเร็จที่อยู่ในชุดของการทดลอง Bernoulli ที่ (ทดลองใช้ Bernoulli คือการทดลองในการที่ตรงสองผลลัพธ์ที่เป็นไปได้: ความสำเร็จหรือความล้มเหลว ) ช่วงเวลาถูกกำหนดโดยสูตรต่อไปนี้:

ค่าสองค่าที่กำหนดโดยสูตรคือขอบเขตบนและล่างของช่วงเวลา n _Sและn _Fคือจำนวนความสำเร็จและความล้มเหลวตามลำดับและnคือจำนวนการทดลองทั้งหมด (เทียบเท่ากับN _S + n _F ) zคือพารามิเตอร์ขึ้นอยู่กับระดับของความมั่นใจที่ต้องการ สำหรับวัตถุประสงค์ของการท้าทายนี้, Z = 1.96 จะใช้ (ตรงกับช่วงเวลาที่ความเชื่อมั่น 95%) 1

รับจำนวนเต็มที่ไม่เป็นลบ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-α/2quantile TH ของการกระจายแบบปกติมาตรฐานซึ่งαเป็นระดับที่มีนัยสำคัญ ถ้าคุณต้องการความเชื่อมั่น 95% ระดับความสำคัญของคุณα=0.05และค่าz1.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ตัวมันเองนั้นยังบันทึกสองสามไบต์ (ส่วนใหญ่ฉันแค่ภูมิใจในการบันทึก byte โดยสังเกตว่า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

Runic Enchantmentsขนาด 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 พระเจ้านี้เป็นระเบียบ นี่คือรุ่นที่ยังไม่ได้เปิด:

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

ทั้งหมดเหล่านั้นyคือการชะลอ IP ที่สองเพื่อให้มาถึงที่Tจุด ransfer ในเวลาที่เหมาะสม (เช่นวินาที) สิ่งนี้จะผลักรายการ 3 อันดับแรกของตัวชี้หนึ่งไปยังอีกรายการหนึ่ง (การตั้งค่าของการกระทำนี้แสดงอยู่ด้านล่าง) 'Ä1C,สร้างzโดยการหารอักขระ 196 โดย 100 (ซ้ำ, สี่เหลี่ยมจัตุรัส, ซ้ำ, div 2, ซ้ำ, div 2 ... ) ทุกสิ่งทุกอย่างเป็นเพียงแค่คณิตศาสตร์และการจัดการสแต็กเพื่อผลักค่าในอนาคตลงในสแต็กจนกว่าพวกเขาจะต้องการ ส่วนใหญ่แล้วพวกเขาจะเรียงลำดับตามลำดับที่ถูกต้องและจนกว่าr4s{++}มันจะต้องย้อนกลับกองซ้อนและหมุนทั้งสิ่งเพื่อให้ได้ค่าที่เราต้องการซึ่งอยู่ติดกัน

อาจมีห้องพักสำหรับการปรับปรุง แต่มันซับซ้อนพอที่ฉันมองไม่เห็น Heck ได้อ่าน "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}

ลองออนไลน์!

$⍺←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

นำปัจจัยการผลิตทั้งในสองสายแยกต่างหากเมื่อภาวนาและเอาท์พุทในสองสายแยกต่างหากที่ถูกผูกไว้บนบนด้านล่างและขอบเขตล่างบนด้านบน

ตัวอย่างเช่น:

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

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

การทดสอบ:

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

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

ลองออนไลน์

ส่งคืนอาเรย์ประเภทสองเท่าของความยาว 2 ซึ่งสามารถตีได้มากกว่านี้

> <>ด้วย-vค่าสถานะ 100 ไบต์

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

n_s, n_fคาดว่าการป้อนข้อมูลที่จะนำเสนอในกองที่เริ่มต้นการดำเนินการในการสั่งซื้อ ลองออนไลน์!

ช่างเป็นภาษาที่โง่ที่จะลองสิ่งนี้ใน ...

ในขณะที่> <> ไม่มีตัวยกกำลังหรือตัวดำเนินการรากที่สองจะถูกคำนวณในบรรทัดที่สองของรหัสโดยใช้วิธีบาบิโลนเพื่อความแม่นยำ1e-8- สำหรับทุกตัวอย่างที่ฉันลองใช้ หากสิ่งนี้ไม่แม่นยำเพียงพอขอบเขตสามารถถูกทำให้แน่นด้วยการเพิ่มมากขึ้น:*ในบรรทัดที่สองและสลับสิ่งต่าง ๆ เพื่อให้กระจกอยู่ในแนวเดียวกัน

เอาต์พุตอยู่ในรูปแบบต่อไปนี้:

<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 bytes) ขาดและɗØ-

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