O intervalo de pontuação de Wilson é um intervalo de confiança da probabilidade de sucesso, com base na proporção de sucessos em um conjunto de ensaios de Bernoulli (um ensaio de Bernoulli é um ensaio no qual exatamente dois resultados são possíveis: sucesso ou fracasso ). O intervalo é dado pela seguinte fórmula:

Os dois valores dados pela fórmula são os limites superior e inferior do intervalo. n _S e n _F são o número de sucessos e falhas, respectivamente, e n é o número total de tentativas (equivalente a n _S + n _F ). z é um parâmetro dependente do nível de confiança desejado. Para os propósitos deste desafio, z = 1,96 será usado (correspondendo a um intervalo de confiança de 95%) ¹ .

Dados inteiros não negativos n _S e n _F , produza os limites do intervalo de pontuação de Wilson.

Regras

• As saídas devem ser tão precisas quanto possível aos valores reais, dentro dos limites da implementação de ponto flutuante do seu idioma, ignorando quaisquer problemas em potencial devido a imprecisões aritméticas de ponto flutuante. Se seu idioma é capaz de aritmética de precisão arbitrária, deve ser pelo menos tão preciso quanto a aritmética de precisão dupla IEEE 754.
• As entradas estarão dentro do intervalo representável para o tipo inteiro nativo do seu idioma e as saídas estarão dentro do intervalo representável para o tipo de ponto flutuante nativo do seu idioma.
• n sempre será positivo.
• A ordem das saídas não importa.

Casos de teste

Formato: 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. O zvalor é o 1-α/2quinto quantil da distribuição normal padrão, onde αestá o nível de significância. Se você deseja um intervalo de confiança de 95%, seu nível de significância é α=0.05e o zvalor é 1.96.

Mathematica, 48 bytes (codificação UTF-8)

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

Função sem nome, recebendo dois argumentos na ordem n_s, n_fe retornando um par ordenado de números reais. O símbolo de três bytes √, representando a função de raiz quadrada, é o U-221A.

Usa o fato de que precedendo ##por um número resulta no produto dos dois argumentos, enquanto +##resulta em sua soma. Também usa o fato de que produtos e somas passam automaticamente sobre listas, de modo que {-1,1}√(...)implementa o ± na fórmula. Definir a constante em s = z^2vez de zsi mesma também salvou alguns bytes. (Principalmente, estou orgulhoso de salvar um byte ao perceber 1.4^4exatamente isso 1.96^2!)

Perl 6 , 66 bytes

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

Essa função realmente retorna uma junção ou dos limites inferior e superior; por exemplo, se chamado com os argumentos 100 e 0, ele retornará:

any(0.963005192523998, 1)

É um formato de saída não tradicional, para dizer o mínimo, mas nenhum formato específico foi especificado e os dois valores necessários estão presentes.

05AB1E , 34 bytes

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

Entrada é no formato [n_s, n_f]
Saída é no formato[upper, lower]

Experimente online!

Explicação

"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

Encantos Rúnicos , 105 bytes

#StillBetterThanJava

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

Experimente online!

Entrada é no formato n_s n_f
Saída é no formatolower upper e possui um espaço à direita

AH DEUS, essa é uma bagunça. Aqui está a versão desembrulhada:

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

Todos esses ys devem desacelerar o segundo IP para que ele chegue ao Tponto de transferência no momento certo (ou seja, o segundo). Isso coloca os 3 principais itens de um ponteiro no outro (a configuração desta ação é mostrada abaixo). 'Ä1C,gera zdividindo o caractere 196 por 100 (dup, quadrado, dup, div 2, dup, div 2 ...). O resto é apenas um monte de matemática e manipulação de pilha para empurrar valores futuros para baixo na pilha até que sejam necessários. Na maioria das vezes, eles acabam na ordem certa e é apenas até r4s{++}que tenhamos que reverter a pilha e girar a coisa toda para obter os valores que queremos próximos um do outro.

Provavelmente há espaço para melhorias, mas é complexo o suficiente para que eu não possa vê-lo. Heck, lera inadvertidamente "Z" em vez de "n" na fórmula original a um ponto de fixação e que era áspero.

Eu tive que retirar os cartões e simular as pilhas para garantir que estavam corretas:

Cada um tem um valor em ambas as extremidades devido ao número de variáveis ​​(por exemplo: eu teria um com S e outro com F, eu os exibia, girava um ao redor e adicionava o S + F que estava em a outra extremidade no topo da pilha). Você pode ver que um dos sqrt(...)cartões tem um Sna borda inferior.

R , 58 53 51 49 41 bytes

-15 bytes graças a J.Doe. -2 bytes graças a Giuseppe.

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

MATL , 38 37 bytes

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

De entrada é uma série de dois números, em qualquer um destes formatos: [25 75], [25, 75], [25; 75].

Experimente online! ou verifique todos os casos de teste .

Haskell , 70 69 68 67 bytes

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

Experimente online!

APL (Dyalog Unicode) , 50 bytes

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

Experimente online!

Infix Dfn, tendo $⍺←n_s$ e $⍵←n_f$.

Agradecimentos a H.PWiz e dzaima por ajudar.

Quão:

                                        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 bytes

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

A saída é um número inteiro complexo com o intervalo armazenado como a parte real / imaginária.

dc , 71 bytes

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

Pega as duas entradas em duas linhas separadas na chamada e as saídas em duas linhas separadas com o limite superior na parte inferior e o limite inferior na parte superior .

Por exemplo:

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

Raquete 134 bytes

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

Teste:

(g 1 10)

Resultado:

0.016231752262825982
0.3773646254862038

Java 7, 130 bytes

Golfe:

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

Experimente online

Retorna uma matriz do tipo dobro do comprimento 2, provavelmente pode ser mais jogado.

> <> com -vsinalizador, 100 bytes

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

Espera que a entrada esteja presente na pilha no início da execução, na ordem n_s, n_f. Experimente online!

Que linguagem estúpida para tentar isso em ...

Como> <> não possui um expoente ou operador raiz, a raiz quadrada é calculada na segunda linha de código usando o método Babylonian , com uma precisão de1e-8 - para cada exemplo que eu tentei, isso é preciso com pelo menos 10 casas decimais. Se isso não for preciso o suficiente, os limites poderão ser reforçados adicionando mais :*na segunda linha, misturando as coisas para manter os espelhos alinhados.

A saída está no seguinte formato:

<lower bound>
<upper bound>

Pitão, 38 bytes

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

A entrada é como uma lista de valores [n_s, n_f],. A saída é [upper, lower]Experimente on-line aqui ou verifique todos os casos de teste de uma vez aqui .

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)

Gelatina , 30 bytes

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

Experimente online!

Explicação

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

Nota

Alguns desses recursos são mais recentes que o desafio. Acredito que na época em que esse desafio foi lançado, ++®¶×÷++1.96²©HH¤×®½×-,1+®H¤+³÷çera válido o Jelly (32 bytes), faltando ɗe Ø-.

APL (NARS), 49 caracteres, 98 bytes

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

teste

  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