Étant donné une série de nombres pour les événements X et Y, calculez le coefficient de corrélation de Pearson. La probabilité de chaque événement est égale, de sorte que les valeurs attendues peuvent être calculées en additionnant simplement chaque série et en divisant par le nombre d'essais.

Contribution

1   6.86
2   5.92
3   6.08
4   8.34
5   8.7
6   8.16
7   8.22
8   7.68
9   12.04
10  8.6
11  10.96

Production

0.769

Le code le plus court gagne. L'entrée peut se faire par stdin ou arg. La sortie se fera par sortie standard.

Modifier: les fonctions intégrées ne doivent pas être autorisées (c'est-à-dire la valeur attendue calculée, la variance, l'écart, etc.) pour permettre une plus grande diversité de solutions. Cependant, n'hésitez pas à démontrer un langage qui convient bien à la tâche à l'aide de builtins (pour exposition).

Basé sur l'idée de David pour l'entrée pour Mathematica (86 caractères utilisant la moyenne intégrée)

m=Mean;x=d[[All,1]];y=d[[All,2]];(m@(x*y)-m@x*m@y)/Sqrt[(m@(x^2)-m@x^2)(m@(y^2)-m@y^2)]

m = Mean;
x = d[[All,1]];
y = d[[All,2]];
(m@(x*y) - m@x*m@y)/((m@(x^2) - m@x^2)(m@(y^2) - m@y^2))^.5

Plinthe en utilisant notre propre moyenne (101 caractères)

m=Total[#]/Length[#]&;x=d[[All,1]];y=d[[All,2]];(m@(x*y)-m@x*m@y)/((m@(x^2)-m@x^2)(m@(y^2)-m@y^2))^.5

m = Total[#]/Length[#]&;
x = d[[All,1]];
y = d[[All,2]];
(m@(x*y)-m@x*m@y)/((m@(x^2)-m@x^2)(m@(y^2)-m@y^2))^.5

PHP 144 octets

<?
for(;fscanf(STDIN,'%f%f',$$n,${-$n});$f+=${-$n++})$e+=$$n;
for(;$$i;$z+=$$i*$a=${-$i++}-=$f/$n,$y+=$a*$a)$x+=$$i*$$i-=$e/$n;
echo$z/sqrt($x*$y);

Prend l'entrée de STDIN, dans le format fourni dans le message d'origine. Résultat:

0,76909044055492

Utilisation du produit vectoriel vectoriel:

où sont les vecteurs d'entrée ajustés à la baisse par et respectivement.

Perl 112 octets

/ /,$e+=$`,$f+=$',@v=($',@v)for@u=<>;
$x+=($_-=$e/$.)*$_,$y+=($;=$f/$.-pop@v)*$;,$z-=$_*$;for@u;
print$z/sqrt$x*$y

0,76909044055492

Même alg, langue différente. Dans les deux cas, de nouvelles lignes ont été ajoutées pour la «lisibilité» et ne sont pas nécessaires. La seule différence notable de longueur est la première ligne: l'analyse de l'entrée.

Mathematica 34 octets

Voici quelques façons d'obtenir la corrélation des moments du produit Pearson. Ils produisent tous le même résultat. Du Dr belisarius: 34 octets

Dot@@Normalize/@(#-Mean@#&)/@{x,y}

Fonction de corrélation intégrée I : 15 caractères

Cela suppose que xet ysont des listes correspondant à chaque variable.

x~Correlation~y

0,76909

Fonction de corrélation II intégrée : 31 caractères

Cela suppose que d est une liste de paires ordonnées.

d[[;;,1]]~Correlation~d[[;;,2]]

0,76909

L'utilisation de ;;pour Allmerci à A Simmons.

S'appuyant sur la fonction d'écart type : 118 115 caractères

La corrélation peut être déterminée par:

s=StandardDeviation;
m=Mean;
n=Length@d;
x=d[[;;,1]];
y=d[[;;,2]];
Sum[((x[[i]]-m@x)/s@x)((y[[i]]-m@y)/s@y),{i,n}]/(n-1)

0,76909

Corrélation roulée à la main : 119 caractères

En supposant xet ysont des listes ...

s=Sum;n=Length@d;m@p_:=Tr@p/n;
(s[(x[[i]]-m@x)(y[[i]]-m@y),{i,n}]/Sqrt@(s[(x[[i]]-m@x)^2,{i,n}] s[(y[[i]] - m@y)^2,{i,n}]))

0,76909

Q

En supposant que les builtins sont autorisés et que les données x, y sont des vecteurs séparés (7 caractères):

x cor y

Si les données sont stockées sous forme de paires ordonnées, comme indiqué par David Carraher, nous obtenons (pour 12 caractères):

{(cor).(+)x}

MATLAB / Octave

À des fins de démonstration des éléments intégrés uniquement:

octave:1> corr(X,Y)
ans =  0.76909
octave:2> 

APL 57

Utilisation de l'approche du produit scalaire:

a←1 2 3 4 5 6 7 8 9 10 11

b←6.86 5.92 6.08 8.34 8.7 8.16 8.22 7.68 12.04 8.6 10.96

(a+.×b)÷((+/(a←a-(+/a)÷⍴a)*2)*.5)×(+/(b←b-(+/b)÷⍴b)*2)*.5

0.7690904406         

J, 30 27 octets

([:+/*%*&(+/)&.:*:)&(-+/%#)

Cette fois comme une fonction prenant deux arguments. Utilise la formule vectorielle pour le calculer.

Usage

   f =: ([:+/*%*&(+/)&.:*:)&(-+/%#)
   (1 2 3 4 5 6 7 8 9 10 11) f (6.86 5.92 6.08 8.34 8.7 8.16 8.22 7.68 12.04 8.6 10.96)
0.76909

Explication

Prend deux listes a et b comme arguments séparés.

([:+/*%*&(+/)&.:*:)&(-+/%#)  Input: a on LHS, b on RHS
                   &(     )  For a and b
                         #     Get the count
                      +/       Reduce using addition to get the sum
                        %      Divide the sum by the count to get the average
                     -         Subtract the initial value from the average
                             Now a and b have both been shifted by their average
                             For both a and b
                *:             Square each value
         (+/)&.:               Reduce the values using addition to get the sum
                               Apply in the inverse of squaring to take the square root
                               of the sum to get the norm
       *&                    Multiply norm(a) by norm(b)
     *                       Multiply a and b elementwise
      %                      Divide a*b by norm(a)*norm(b) elementwise
 [:+/                        Reduce using addition to the sum which is the
                             correlation coefficient and return it

Python 3, 140 octets

E=lambda x:sum(x)/len(x)
S=lambda x:(sum((E(x)-X)**2for X in x)/len(x))**.5
lambda x,y:E([(X-E(x))*(Y-E(y))for X,Y in zip(x,y)])/S(x)/S(y)

2 fonctions d'assistance ( Eet S, pour la valeur attendue et l'écart type, respectivement) sont définies. L'entrée est attendue comme 2 itérables (listes, tuples, etc.). Essayez-le en ligne .

Oracle SQL 11.2, 152 octets (pour exposition)

SELECT CORR(a,b)FROM(SELECT REGEXP_SUBSTR(:1,'[^ ]+',1,2*LEVEL-1)a,REGEXP_SUBSTR(:1,'[^ ]+',1,2*LEVEL)b FROM DUAL CONNECT BY INSTR(:1,' ',2,LEVEL-1)>0);

Non golfé

SELECT CORR(a,b)
FROM
(
  SELECT REGEXP_SUBSTR(:1, '[^ ]+', 1, 2*LEVEL-1)a, REGEXP_SUBSTR(:1, '[^ ]+', 1, 2*LEVEL)b
  FROM DUAL
  CONNECT BY INSTR(:1, ' ', 2, LEVEL - 1) > 0
)

La chaîne d'entrée doit utiliser le même séparateur décimal que la base de données.

Python 3 avec SciPy, 52 octets (pour exposition)

from scipy.stats import*
lambda x,y:pearsonr(x,y)[0]

Une fonction anonyme qui prend l'entrée des deux ensembles de données sous forme de listes xet y, et retourne le coefficient de corrélation.

Comment ça fonctionne

Il ne se passe pas grand-chose ici; SciPy a une fonction intégrée qui renvoie à la fois le coefficient et la valeur de p pour tester la non-corrélation, de sorte que la fonction passe simplement les ensembles de données à cela et renvoie le premier élément du (coefficient, p-value)tuple renvoyé par la fonction intégrée.

Essayez-le sur Ideone