Wilson skor aralığı Bernoulli denemelerinin kümesindeki başarı oranına dayalı başarı olasılığı bir güven aralığı vardır (: Bernoulli deneme tam iki sonuçların mümkün olduğu bir deneme olduğunu başarı veya başarısızlık ). Aralık aşağıdaki formülle verilir:

Formül tarafından verilen iki değer, aralığın üst ve alt sınırlarıdır. n _S ve n _F , sırasıyla başarı ve başarısızlık sayısıdır ve n , toplam deneme sayısıdır ( n _S + n _F'ye eşdeğer ). z , istenen güven seviyesine bağlı bir parametredir. Bu zorluğun amaçları için, z = 1.96 kullanılacaktır (% 95 güven aralığına karşılık gelir) ¹ .

Negatif olmayan tamsayı n _S ve n _F verildiğinde, Wilson skor aralığının sınırlarını çıktılayın.

kurallar

• Çıktılar, dilinizin kayan nokta uygulaması sınırları dahilinde kayan nokta aritmetik yanlışlıkları nedeniyle oluşabilecek olası sorunları göz ardı ederek gerçek değerlere mümkün olduğunca doğru olmalıdır. Diliniz keyfi hassasiyetli aritmetik yapabiliyorsa, en azından IEEE 754 çift hassasiyetli aritmetik kadar hassas olmalıdır.
• Girişler, dilinizin yerel tam sayı türü için temsil edilebilir aralıkta ve çıkışlar dilinizin yerel kayan nokta türü için temsil edilebilir aralıkta olacaktır.
• n her zaman pozitif olacaktır.
• Çıkışların sırası önemli değil.

Test Durumları

Biçim: 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. zDeğerdir 1-α/2standart normal dağılımın, inci kuantil αanlamlılık düzeyidir. % 95 güven aralığı istiyorsanız, önem düzeyiniz α=0.05ve zdeğerdir 1.96.

Mathematica, 48 bayt (UTF-8 kodlaması)

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

Adsız fonksiyon, sırayla iki argüman alarak n_s, n_fve sıralı bir çift gerçek sayı döndürür. √Karekök işlevini temsil eden üç baytlık simge U-221A'dır.

Sayıdan önce gelmek ##, iki argümanın çarpımıyla +##sonuçlanırken, toplamıyla sonuçlanır. Ayrıca, ürünlerin ve toplamların listeler üzerinde otomatik olarak işlenmesi gerçeğini kullanır, böylece {-1,1}√(...)formülde ± uygular. Kendisi s = z^2yerine sabiti tanımlamak zda birkaç bayt kurtardı. (Çoğunlukla 1.4^4bunun tam olarak olduğunu fark ederek bir bayt tasarrufu yapmaktan gurur duyuyorum 1.96^2!)

Perl 6 , 66 bayt

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

Bu işlev aslında alt ve üst sınırların bir veya birleşme noktasını döndürür; örneğin, 100 ve 0 bağımsız değişkenleriyle çağrılırsa, döndürür:

any(0.963005192523998, 1)

En azını söylemek geleneksel olmayan bir çıktı biçimidir, ancak belirli bir biçim belirtilmedi ve gerekli değerlerin her ikisi de var.

05AB1E , 34 bayt

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

Girdi şu şekildedir [n_s, n_f]
Çıktı şu şekildedir[upper, lower]

Çevrimiçi deneyin!

açıklama

"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

Runik Efsunlar , 105 bayt

#StillBetterThanJava

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

Çevrimiçi deneyin!

Girdi biçimindedir n_s n_f
Çıktı biçimdedir lower upperve sondaki boşluğu vardır

AH TANRIM bu bir karmaşa. İşte açılmamış versiyon:

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

Tüm ybunlar ikinci IP'yi yavaşlatacak ve böylece Tdoğru zamanda (yani ikinci) fidye noktasına ulaşacaktır. Bu, bir işaretçinin ilk 3 öğesini diğerine doğru iter (bu eylemin kurulumu aşağıda gösterilmiştir). 196 karakterini 100'e bölerek 'Ä1C,üretir z(dup, kare, dup, div 2, dup, div 2 ...). Diğer her şey, gelecekteki değerleri ihtiyaç duyulana kadar yığını aşağı itmek için bir grup matematik ve yığın manipülasyonudur. Çoğunlukla, doğru sırayla sonuçlanırlar ve sadece r4s{++}yığının tersini çevirmek ve yan yana istediğimiz değerleri almak için her şeyi döndürmek zorunda kalana kadar .

Muhtemelen iyileştirme için yer var, ama göremediğim kadar karmaşık. Heck, yanlışlıkla bir noktada orijinal formülde "n" yerine "z" okumuştu ve bu da kaba oldu.

Doğru olduğundan emin olmak için notları çıkarmak ve yığınları simüle etmek zorunda kaldım:

Her birinin, her iki uçta da kaç değişken olduğu için her iki uçta bir değeri vardır (örneğin, S ile bir ve F ile bir tane olurdu, ikisini de patlatacağım, bir tane çevirin ve üzerinde olan S + F'yi ekleyin diğer ucu yığının en üstüne). Sen birini görebilirsiniz sqrt(...)kartları bir sahiptir Salt kenarında.

R , 58 53 51 49 41 bayt

J.Doe sayesinde -15 bayt. Giuseppe sayesinde -2 bayt.

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

MATL , 38 37 bayt

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

Girdi bu biçimlerin herhangi iki sayının bir dizidir: [25 75], [25, 75], [25; 75].

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Haskell , 70 69 68 67 bayt

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

Çevrimiçi deneyin!

APL (Dyalog Unicode) , 50 bayt

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

Çevrimiçi deneyin!

Infix Dfn, alarak $⍺←n_s$ ve $⍵←n_f$.

Yardım ettiği için H.PWiz ve dzaima'ya teşekkürler.

Nasıl:

                                        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 bayt

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

Çıktı, gerçek / hayali kısım olarak saklanan aralıklı karmaşık bir tamsayıdır.

dc , 71 bayt

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

Üst ile bağlanmış olan iki ayrı hat hem başlatmadan sonra iki ayrı hat üzerinde giriş ve çıkışları alır alt ve ilgili alt sınır en .

Örneğin:

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

Raket 134 bayt

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

Test yapmak:

(g 1 10)

Çıktı:

0.016231752262825982
0.3773646254862038

Java 7, 130 bayt

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

Çevrimiçi deneyin

Uzunluğunda 2 tipi çift dizi döndürür, muhtemelen daha fazla golf olabilir.

> <> İle -vbayrak, 100 bayt

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

Sıranın yürütme başlangıcında sırayla bulunmasını bekler n_s, n_f. Çevrimiçi deneyin!

Bunu denemek için ne kadar aptal bir dil ...

> <> Bir üs veya kök operatörüne sahip olmadığından, karekök, ikinci kod satırında Babil yöntemi kullanılarak hesaplanır , doğruluk için 1e-8- denediğim her örnek için, bu en az 10 ondalık basamak için doğrudur. Bu yeterince kesin değilse, sınırlar daha fazla eklenerek sıkılabilir:* ikinci çizgiye şey , aynaları aynı hizada tutmak için etrafta bir şeyler karıştırarak .

Çıktı aşağıdaki biçimde:

<lower bound>
<upper bound>

Pyth, 38 bayt

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

Girdi, değerler listesidir [n_s, n_f],. Çıktı burada[upper, lower] çevrimiçi deneyin veya tüm test senaryolarını burada bir kerede doğrulayın .

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)

Jöle , 30 bayt

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

Çevrimiçi deneyin!

açıklama

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

Not

Bu özelliklerin bazıları meydan okumadan daha yenidir. Bu zorluğun yayınlandığı zaman ++®¶×÷++1.96²©HH¤×®½×-,1+®H¤+³÷ç, geçerli Jelly (32 bayt), eksik ɗve olduğuna inanıyorum Ø-.

APL (NARS), 49 karakter, 98 bayt

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

Ölçek

  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