विल्सन स्कोर अंतराल सफलता की प्रायिकता के विश्वास अंतराल, Bernoulli परीक्षणों का एक सेट में सफलता के अनुपात पर आधारित है (: एक Bernoulli परीक्षण एक जिसमें ठीक दो परिणामों संभव हो रहे हैं परीक्षण है सफलता या विफलता )। अंतराल निम्नलिखित सूत्र द्वारा दिया गया है:

सूत्र द्वारा दिए गए दो मान अंतराल के ऊपरी और निचले सीमा हैं। 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

zमूल्य 1-α/2मानक सामान्य बंटन, जहां की वें quantile αमहत्व स्तर है। यदि आप एक 95% विश्वास अंतराल चाहते हैं, तो आपका महत्व स्तर है α=0.05, और zमूल्य है 1.96।

— मै जाऊं
स्रोत

संबंधित: पश्चिम समस्या में सबसे तेज गन । मैं इसे चुनौती देने जा रहा था, लेकिन मुझे लगता है कि आपने मुझे हरा दिया। : /

— mbomb007

6

गणितज्ञ, 48 बाइट्स (UTF-8 एन्कोडिंग)

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

आदेश में दो तर्कों को लेने n_s, n_fऔर वास्तविक संख्याओं के आदेशित जोड़ी को वापस करने का कार्य करें । √स्क्वायर-रूट फ़ंक्शन का प्रतिनिधित्व करने वाला तीन-बाइट का प्रतीक U-221A है।

इस तथ्य का उपयोग करता है कि ##दो तर्कों के उत्पाद में संख्या के परिणाम से पहले , जबकि +##उनकी राशि में परिणाम होता है। इस तथ्य का भी उपयोग करता है कि उत्पाद और रकम स्वचालित रूप से सूचियों पर थ्रेड करते हैं, ताकि सूत्र में products को {-1,1}√(...)लागू किया जा सके। खुद के s = z^2बजाय स्थिरांक को परिभाषित करने से zभी बाइट्स के एक जोड़े को बचाया। (ज्यादातर मैं सिर्फ एक बाइट को देखकर गर्व महसूस कर रहा हूं जो 1.4^4वास्तव में है 1.96^2!)

— ग्रेग मार्टिन
स्रोत

क्या गणितज्ञ मनमानी एनकोडिंग का उपयोग कर सकते हैं? वर्गाकार रूट प्रतीक 1 बाइट में एकल-बाइट एन्कोडिंग का एक बहुत है।

— मेघो

यह वास्तव में कई एन्कोडिंग का उपयोग कर सकता है - उदाहरण के लिए, मैक ओएस रोमन, जिसमें आपके द्वारा उल्लेखित संपत्ति है। मेरी समझ, हालांकि, यह है कि मुझे गैर-डिफ़ॉल्ट एन्कोडिंग पर स्विच करने के लिए आवश्यक बाइट्स को शामिल करना होगा, जो इस मामले में 2 "बर्बाद" बाइट्स से अधिक है।

— ग्रेग मार्टिन

ओह, इसके लिए कमांड लाइन स्विच (या कुछ फ़ंक्शन कॉल) की आवश्यकता है? कुल।

— मेघो

4

Mathematica भयानक और स्थूल का एक अद्भुत रस है: D

— ग्रेग मार्टिन

3

पर्ल 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)

यह कम से कम कहने के लिए एक गैर-पारंपरिक आउटपुट प्रारूप है, लेकिन कोई विशेष प्रारूप निर्दिष्ट नहीं किया गया था, और दोनों आवश्यक मान मौजूद हैं।

— शॉन
स्रोत

यह मुझे ठीक लगता है। एक विशिष्ट आउटपुट प्रारूप की कमी जानबूझकर थी - आउटपुट के लिए एक विशिष्ट प्रारूप की आवश्यकता कुछ भाषाओं को लाभ देती है, और अनावश्यक रूप से चुनौती को जटिल बनाती है। जब तक दोनों आउटपुट वैल्यू कुछ प्रयोग करने योग्य रूप में मौजूद हैं, तब तक यह स्वीकार्य है।

— मीगो

3

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

— Emigna
स्रोत

3

रूनिक एनकाउंटर , 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को दूसरे आईपी को धीमा करना है ताकि यह Tसही समय (यानी दूसरे) पर रैन्फर बिंदु पर पहुंचे । यह एक पॉइंटर के शीर्ष 3 आइटम को दूसरे पर भेजता है (इस क्रिया के लिए सेटअप नीचे दर्शाया गया है)। वर्ण १ ९ ६ को १०० से विभाजित करके 'Ä1C,उत्पन्न करता zहै (द्वैध, वर्ग, द्विप, दिव २, द्विप, दव २ ...)। बाकी सब कुछ सिर्फ गणित का एक गुच्छा है और भविष्य के मूल्यों को ढेर करने के लिए स्टैक हेरफेर करते हैं जब तक कि वे आवश्यक न हों। अधिकांश भाग के लिए, वे सही क्रम में समाप्त होते हैं और इसके केवल तब तक जब तक r4s{++}हम एक दूसरे के बगल में एक दूसरे के बगल में चाहते मूल्यों को प्राप्त करने के लिए स्टैक को उल्टा करते हैं और पूरी चीज को घुमाते हैं।

वहाँ शायद सुधार के लिए जगह है, लेकिन इसके जटिल पर्याप्त है कि मैं इसे नहीं देख सकता। हेक ने अनजाने में एक बिंदु पर मूल सूत्र में "n" के बजाय "z" पढ़ा था और यह तय करना कि यह किसी न किसी तरह था।

मुझे यह सुनिश्चित करने के लिए कि इसे सही किया गया था, स्टेक को बाहर निकालने और ढेर लगाने के लिए अनुकरण करना पड़ा:

हर एक का दोनों सिरों पर एक मान होता है कि कितने वेरिएबल थे (जैसे। मेरे पास S के साथ एक होगा और F के साथ एक, मैं उन दोनों को पॉप करूँगा, एक को चारों ओर फ्लिप करूँगा और जो S + F था उस पर जोड़ देगा स्टैक के शीर्ष पर दूसरा छोर)। आप देख सकते हैं कि sqrt(...)कार्ड में से एक Sके निचले किनारे पर है।

— Draco18s को अब SE पर भरोसा नहीं है
स्रोत

3

आर , 58 53 51 49 41 बाइट्स

-15 बाइट्स जे। थोडा धन्यवाद। -2 बाइट्स ग्यूसेप के लिए धन्यवाद।

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

— रॉबर्ट एस।
स्रोत

1

मुझे यह पसंद है जब आर गोल्फ भाषाओं के साथ प्रतिस्पर्धा कर रहा है ...

— जे। डी। ओ।

2

MATL , 38 37 बाइट्स

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

इनपुट दो नंबर की एक सरणी, इन स्वरूपों में से किसी में है: [25 75], [25, 75], [25; 75]।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

— लुइस मेंडो
स्रोत

2

हास्केल , 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]]

इसे ऑनलाइन आज़माएं!

— flawr
स्रोत

2

एपीएल (डायलॉग यूनिकोड) , 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²

— जे। सल्ल
स्रोत

40:z←1.9208⋄(z+⊣(-,+).5*⍨z×z+2×⊣×⊢÷+)÷z+z++

— अदम

@ Adám यह न तो एक अभिव्यक्ति है, न ही एक पूर्ण कार्यक्रम, लेकिन आप इसे zइसके सबसे सही उपयोग पर आरंभ करके एक अभिव्यक्ति बना सकते हैं : ...÷z+(z←1.908)++उसी बाइट की गिनती के लिए। इसके अलावा: ⊣×⊢÷+->×÷+

— ngn

1

@ng सही, लेकिन वास्तव में, यह डबल मेटा सर्वसम्मति द्वारा अनुमति है: (1) और (2) ।

— अड्म

1

पायथन, 79 67 बाइट्स

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

आउटपुट वास्तविक / काल्पनिक भाग के रूप में संग्रहीत अंतराल के साथ एक जटिल पूर्णांक है।

— orlp
स्रोत

1

डीसी , 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

— आर। कप
स्रोत

1

रैकेट 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

— rnso
स्रोत

1

जावा 7, 130 बाइट्स

golfed:

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 के प्रकार की एक सरणी देता है, शायद अधिक गोल्फ हो सकता है।

— peech
स्रोत

1

> <>`-v` ध्वज के साथ , 100 बाइट्स

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

ऑर्डर में निष्पादन शुरू होने पर स्टैक पर मौजूद इनपुट की अपेक्षा करता है n_s, n_f। इसे ऑनलाइन आज़माएं!

क्या यह कोशिश करने के लिए एक मूर्ख भाषा ...

के रूप में> <> एक घातांक या रूट ऑपरेटर की कमी है, वर्गमूल की गणना बेबीलोनियन विधि का उपयोग करके कोड की दूसरी पंक्ति में की जाती है , सटीकता के लिए 1e-8- मैंने कोशिश की है हर उदाहरण के लिए, यह कम से कम 10 दशमलव स्थानों के लिए सटीक है। यदि यह पर्याप्त सटीक नहीं है, तो :*दूसरी पंक्ति में अधिक जोड़कर , दर्पण में लाइन रखने के लिए चीजों को फेरबदल करके सीमा को कड़ा किया जा सकता है ।

आउटपुट निम्न रूप में है:

<lower bound>
<upper bound>

— सोक
स्रोत

1

पायथ, 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)

— सोक
स्रोत

1

जेली , 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 बाइट्स) था, कमी ɗऔर Ø-।

— लिन
स्रोत

1

एपीएल (एनएआरएस), 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

— RosLuP
स्रोत

विल्सन स्कोर अंतराल की गणना करें

नियम

परीक्षण के मामलों

गणितज्ञ, 48 बाइट्स (UTF-8 एन्कोडिंग)

पर्ल 6 , 66 बाइट्स

05AB1E , 34 बाइट्स

रूनिक एनकाउंटर , 105 बाइट्स

आर , 58 53 51 49 41 बाइट्स

MATL , 38 37 बाइट्स

हास्केल , 70 69 68 67 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 50 बाइट्स

किस तरह:

पायथन, 79 67 बाइट्स

डीसी , 71 बाइट्स

रैकेट 134 बाइट्स

जावा 7, 130 बाइट्स

> <>-v ध्वज के साथ , 100 बाइट्स

पायथ, 38 बाइट्स

जेली , 30 बाइट्स

व्याख्या

ध्यान दें

एपीएल (एनएआरएस), 49 चार्ट, 98 बाइट्स

> <>`-v` ध्वज के साथ , 100 बाइट्स