El intervalo de puntuación de Wilson es un intervalo de confianza de la probabilidad de éxito, basado en la proporción de éxitos en un conjunto de ensayos de Bernoulli (un ensayo de Bernoulli es un ensayo en el que son posibles exactamente dos resultados: éxito o fracaso ). El intervalo viene dado por la siguiente fórmula:

Los dos valores dados por la fórmula son los límites superior e inferior del intervalo. n _S y n _F son el número de éxitos y fracasos, respectivamente, yn es el número total de pruebas (equivalente a n _S + n _F ). z es un parámetro que depende del nivel de confianza deseado. Para los propósitos de este desafío, se utilizará z = 1.96 (correspondiente a un intervalo de confianza del 95%) ¹ .

Enteros no negativos Dadas n _S y n _F , la salida de los límites de la Wilson puntuación de intervalo.

Reglas

• Los resultados deben ser lo más precisos posible a los valores verdaderos, dentro de los límites de la implementación de punto flotante de su idioma, ignorando cualquier problema potencial debido a imprecisiones aritméticas de punto flotante. Si su lenguaje es capaz de una aritmética de precisión arbitraria, debe ser al menos tan precisa como la aritmética de doble precisión IEEE 754.
• Las entradas estarán dentro del rango representable para el tipo de entero nativo de su idioma, y ​​las salidas estarán dentro del rango representable para el tipo de punto flotante nativo de su idioma.
• n siempre será positivo.
• El orden de las salidas no importa.

Casos de prueba

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. El zvalor es el 1-α/2cuantil cuantil de la distribución normal estándar, donde αes el nivel de significancia. Si desea un intervalo de confianza del 95%, su nivel de significancia es α=0.05y el zvalor es 1.96.

Mathematica, 48 bytes (codificación UTF-8)

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

Función sin nombre que toma dos argumentos en el orden n_s, n_fy devuelve un par ordenado de números reales. El símbolo de tres bytes √, que representa la función de raíz cuadrada, es U-221A.

Utiliza el hecho de que preceder ##por un número da como resultado el producto de los dos argumentos, mientras que +##da como resultado su suma. También utiliza el hecho de que los productos y las sumas se enhebran automáticamente en las listas, por lo que {-1,1}√(...)implementa el ± en la fórmula. La definición de la constante en s = z^2lugar de zsí misma también ahorró un par de bytes. (¡Sobre todo estoy orgulloso de guardar un byte al notar que 1.4^4es exactamente 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)}

Esta función en realidad devuelve una unión o de los límites inferior y superior; por ejemplo, si se llama con los argumentos 100 y 0, devuelve:

any(0.963005192523998, 1)

Es un formato de salida no tradicional, por decir lo menos, pero no se especificó ningún formato en particular, y ambos valores requeridos están presentes.

05AB1E , 34 bytes

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

La entrada es de la forma [n_s, n_f]
salida es de la forma[upper, lower]

Pruébalo en línea!

Explicación

"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

Encantamientos rúnicos , 105 bytes

#StillBetterThanJava

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

Pruébalo en línea!

La entrada es de la forma Lan_s n_f
salida es de la formalower upper y tiene un espacio final

AH DIOS, este es un desastre. Aquí está la versión sin envolver:

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

Todos esos ys deben reducir la velocidad de la segunda IP para que llegue al Tpunto de transferencia en el momento adecuado (es decir, la segunda). Esto empuja los 3 elementos principales de un puntero al otro (la configuración de esta acción se muestra a continuación). 'Ä1C,se genera zdividiendo el carácter 196 por 100 (dup, cuadrado, dup, div 2, dup, div 2 ...). Todo lo demás es solo un montón de manipulación matemática y de pila para empujar los valores futuros por la pila hasta que sean necesarios. En su mayor parte, terminan en el orden correcto y es solo hastar4s{++} que tenemos que invertir la pila y rotar todo para obtener los valores que queremos uno al lado del otro.

Probablemente haya margen de mejora, pero es lo suficientemente complejo como para que no pueda verlo. Heck, había leído inadvertidamente "z" en lugar de "n" en la fórmula original en un punto y corrigiendo eso era tosco.

Tuve que sacar tarjetas de notas y simular las pilas para asegurarme de que era correcto:

Cada uno tiene un valor en ambos extremos debido a la cantidad de variables que había (por ejemplo, tendría una con S y otra con F, las sacaría a ambas, voltearía una y agregaría la S + F que estaba activada). el otro extremo a la cima de la pila). Puedes ver que una de las sqrt(...)cartas tiene un Sborde inferior.

R , 58 53 51 49 41 bytes

-15 bytes gracias a J.Doe. -2 bytes gracias 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 es una matriz de dos números, en cualquiera de estos formatos: [25 75], [25, 75], [25; 75].

Pruébalo en línea! o verificar todos los casos de prueba .

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

Pruébalo en línea!

APL (Dyalog Unicode) , 50 bytes

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

Pruébalo en línea!

$⍺←n_s$$⍵←n_f$

Gracias a H.PWiz y dzaima por ayudar.

Cómo:

                                        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)

La salida es un número entero complejo con el intervalo almacenado como la parte real / imaginaria.

dc , 71 bytes

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

Toma ambas entradas en dos líneas separadas tras la invocación, y las salidas en dos líneas separadas con el límite superior en el parte inferior y el límite inferior en la parte superior .

Por ejemplo:

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

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

Sin golf:

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

Pruebas:

(g 1 10)

Salida:

0.016231752262825982
0.3773646254862038

Java 7, 130 bytes

Golfizado:

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

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

Pruébalo en línea

Devuelve una matriz de tipo doble de longitud 2, probablemente se puede jugar más.

> <> con -vbandera, 100 bytes

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

Espera que la entrada esté presente en la pila al inicio de la ejecución, en el orden n_s, n_f. Pruébalo en línea!

Qué lenguaje tan estúpido para intentar esto ...

Como> <> carece de un exponente u operador de raíz, la raíz cuadrada se calcula en la segunda línea de código utilizando el método babilónico , con una precisión de 1e-8- por cada ejemplo que he probado, esto es exacto al menos con 10 decimales. Si esto no es lo suficientemente preciso, los límites se pueden ajustar agregando más :*en la segunda línea, barajando las cosas para mantener los espejos en línea.

La salida tiene la siguiente forma:

<lower bound>
<upper bound>

Pyth, 38 bytes

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

La entrada es como una lista de valores, [n_s, n_f]. La salida es [upper, lower]Pruébelo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

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)

Jalea , 30 bytes

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

Pruébalo en línea!

Explicación

                   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

Algunas de estas características son más nuevas que el desafío. Creo que en el momento en que se publicó este desafío, ++®¶×÷++1.96²©HH¤×®½×-,1+®H¤+³÷çera válido Jelly (32 bytes), faltante ɗy Ø-.

APL (NARS), 49 caracteres, 98 bytes

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

prueba

  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