L' intervalle de score de Wilson est un intervalle de confiance de la probabilité de succès, basé sur la proportion de succès dans un ensemble d'essais de Bernoulli (un essai de Bernoulli est un essai dans lequel exactement deux résultats sont possibles: succès ou échec ). L'intervalle est donné par la formule suivante:

Les deux valeurs données par la formule sont les limites supérieure et inférieure de l'intervalle. n _S et n _F sont le nombre de succès et d'échecs, respectivement, et n est le nombre total d'essais (équivalent à n _S + n _F ). z est un paramètre dépendant du niveau de confiance souhaité. Aux fins de ce défi, z = 1,96 sera utilisé (correspondant à un intervalle de confiance à 95%) ¹ .

Étant donné les entiers non négatifs n _S et n _F , affichez les limites de l'intervalle de score de Wilson.

Règles

• Les sorties doivent être aussi précises que possible par rapport aux vraies valeurs, dans les limites de l'implémentation en virgule flottante de votre langue, en ignorant les problèmes potentiels dus aux inexactitudes arithmétiques en virgule flottante. Si votre langage est capable d'arithmétique à précision arbitraire, il doit être au moins aussi précis que l'arithmétique à double précision IEEE 754.
• Les entrées seront dans la plage représentable pour le type entier natif de votre langue, et les sorties seront dans la plage représentable pour le type natif à virgule flottante de votre langue.
• n sera toujours positif.
• L'ordre des sorties n'a pas d'importance.

Cas de test

Format: 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. La zvaleur est le 1-α/2e quantile de la distribution normale standard, où αest le niveau de signification. Si vous voulez un intervalle de confiance à 95%, votre niveau de signification est α=0.05et la zvaleur est 1.96.

Mathematica, 48 octets (encodage UTF-8)

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

Fonction sans nom prenant deux arguments dans l'ordre n_s, n_fet renvoyant une paire ordonnée de nombres réels. Le symbole à trois octets √, représentant la fonction racine carrée, est U-221A.

Utilise le fait que précéder ##d'un nombre donne le produit des deux arguments, tandis que +##leur somme. Utilise également le fait que les produits et les sommes passent automatiquement sur les listes, ce qui {-1,1}√(...)implémente le ± dans la formule. La définition de la constante s = z^2au lieu de zlui - même a également permis d'économiser quelques octets. (Surtout, je suis juste fier d'économiser un octet en remarquant que 1.4^4c'est exactement 1.96^2!)

Perl 6 , 66 octets

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

Cette fonction renvoie en fait une jonction or des bornes inférieure et supérieure; par exemple, s'il est appelé avec les arguments 100 et 0, il renvoie:

any(0.963005192523998, 1)

C'est un format de sortie non traditionnel pour le moins, mais aucun format particulier n'a été spécifié, et les deux valeurs requises sont présentes.

05AB1E , 34 octets

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

L'entrée est de la forme La [n_s, n_f]
sortie est de la forme[upper, lower]

Essayez-le en ligne!

Explication

"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

Enchantements runiques , 105 octets

#StillBetterThanJava

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

Essayez-le en ligne!

L'entrée est de la forme La n_s n_f
sortie est de la forme lower upperet a un espace de fin

AH DIEU celui-ci est un gâchis. Voici la version non emballée:

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

Tous ces ys doivent ralentir la deuxième IP afin qu'elle arrive au Tpoint de transfert au bon moment (c'est-à-dire la seconde). Cela pousse les 3 premiers éléments d'un pointeur sur l'autre (la configuration de cette action est illustrée ci-dessous). 'Ä1C,génère zen divisant le caractère 196 par 100 (dup, carré, dup, div 2, dup, div 2 ...). Tout le reste n'est qu'un tas de mathématiques et de manipulation de pile pour pousser les valeurs futures dans la pile jusqu'à ce qu'elles soient nécessaires. Pour la plupart, ils se retrouvent dans le bon ordre et c'est seulement jusqu'à ce r4s{++}que nous devions inverser la pile et faire pivoter le tout pour obtenir les valeurs que nous voulons côte à côte.

Il y a probablement matière à amélioration, mais c'est suffisamment complexe pour que je ne puisse pas le voir. Heck, avait par inadvertance lu "z" au lieu de "n" dans la formule originale à un moment donné et la fixation qui était rude.

J'ai dû retirer des fiches et simuler les piles afin de m'assurer que c'était correct:

Chacun a une valeur aux deux extrémités en raison du nombre de variables (par exemple, j'en aurais une avec S et une avec F, je les afficherais toutes les deux, en inverser une et ajouter le S + F qui était sur l'autre extrémité en haut de la pile). Vous pouvez voir que l'une des sqrt(...)cartes a un Ssur le bord inférieur.

R , 58 53 51 49 41 octets

-15 octets grâce à J.Doe. -2 octets grâce à Giuseppe.

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

MATL , 38 37 octets

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

L' entrée est un tableau de deux nombres, dans l' un de ces formats: [25 75], [25, 75], [25; 75].

Essayez-le en ligne! ou vérifiez tous les cas de test .

Haskell , 70 69 68 67 octets

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

Essayez-le en ligne!

APL (Dyalog Unicode) , 50 octets

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

Essayez-le en ligne!

$⍺←n_s$$⍵←n_f$

Merci à H.PWiz et dzaima pour leur aide.

Comment:

                                        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 octets

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

La sortie est un entier complexe avec l'intervalle stocké en tant que partie réelle / imaginaire.

dc , 71 octets

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

Prend les deux entrées sur deux lignes distinctes lors de l'invocation et les sorties sur deux lignes distinctes avec la limite supérieure en bas et la limite inférieure en haut .

Par exemple:

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

Raquette 134 octets

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

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

Essai:

(g 1 10)

Production:

0.016231752262825982
0.3773646254862038

Java 7, 130 octets

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

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

Essayez-le en ligne

Retourne un tableau de type double de longueur 2, peut probablement être joué plus.

> <> avec -vindicateur, 100 octets

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

Attend que l'entrée soit présente sur la pile au début de l'exécution, dans l'ordre n_s, n_f. Essayez-le en ligne!

Quelle langue stupide pour tenter cela dans ...

Comme> <> n'a pas d'exposant ou d'opérateur racine, la racine carrée est calculée dans la deuxième ligne de code en utilisant la méthode babylonienne , avec une précision de 1e-8- pour chaque exemple que j'ai essayé, elle est précise à au moins 10 décimales. Si ce n'est pas assez précis, les limites peuvent être resserrées en ajoutant plus :*dans la deuxième ligne, en mélangeant les choses pour garder les miroirs en ligne.

La sortie se présente sous la forme suivante:

<lower bound>
<upper bound>

Pyth, 38 octets

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

L' entrée est sous forme de liste de valeurs [n_s, n_f]. La sortie est [upper, lower]Essayez-le en ligne ici , ou vérifiez tous les cas de test à la fois ici .

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)

Gelée , 30 octets

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

Essayez-le en ligne!

Explication

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

Remarque

Certaines de ces fonctionnalités sont plus récentes que le défi. Je crois qu'à l'époque où ce défi a été publié, ++®¶×÷++1.96²©HH¤×®½×-,1+®H¤+³÷çétait une gelée valide (32 octets), manquante ɗet Ø-.

APL (NARS), 49 caractères, 98 octets

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

tester

  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