Calcular desviación estándar

19

Desafío

Dada una lista de números, calcule la desviación estándar de la población de la lista.

Use la siguiente ecuación para calcular la desviación estándar de la población:

Entrada

La entrada será una lista de enteros en cualquier formato (lista, cadena, etc.). Algunos ejemplos:

56,54,89,87
67,54,86,67

Los números siempre serán enteros.

La entrada será a STDIN o argumentos de función.

Salida

La salida debe ser un número de coma flotante.

Reglas

Puede usar funciones integradas para encontrar la desviación estándar.

Su respuesta puede ser un programa completo o una función.

Ejemplos

10035, 436844, 42463, 44774 => 175656.78441352615

45,67,32,98,11,3 => 32.530327730015607

1,1,1,1,1,1 => 0.0

Victorioso

El programa o función más corto gana.

Tabla de clasificación

Decaimiento Beta
fuente
1
¿Quiere decir que la salida debe ser un punto flotante O entero?
Mutador
3
Creo que la mayoría de las funciones de desviación estándar incorporadas calculan la desviación estándar de muestra.
Mutador
¿Qué pasa si la lista de entrada es nula? 175656.78441352615 resultado para mí 175656.78441352614
RosLuP
@RosLuP No tiene que preocuparse por eso
Beta Decay
1
@ a13a22 De acuerdo con las reglas estándar de PPCG, está bien recibir información a través de argumentos de función
Decaimiento Beta

Respuestas:

18

Clip , 3

.sk

.ses la desviación estándar, kanaliza la entrada en el formulario {1,2,3}.

Ypnypn
fuente
¿Qué fórmula se usa para la desviación estándar? No pude encontrarlo en la referencia.
flawr
@flawr Es este gráfico , hacia abajo.
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Lo vi, pero no hay una fórmula dada.
flawr
@flawr Oh, ya veo. Quizás entonces depende del intérprete, si tal cosa existe.
Conor O'Brien
2
@ CᴏɴᴏʀO'Bʀɪᴇɴ Lo encontré aquí en la línea 493, ¡parece estar bien!
flawr
11

Mathematica, 24 22 bytes

Agradable, Mathematica tiene un StandardDevi...oh incorporado ... que calcula la desviación estándar de la muestra, no la desviación estándar de la población.

Pero y si usamos Variance... oh ... mismo trato.

Pero hay otra función integrada relacionada:

CentralMoment[#,2]^.5&

Hurra. :)

Esto también funciona para 22 bytes:

Mean[(#-Mean@#)^2]^.5&

Y esto por 27:

N@RootMeanSquare[#-Mean@#]&
Martin Ender
fuente
10

Octava, 14 bytes

g=@(a)std(a,1)

Pruébalo con ideone .

cubilete
fuente
2
Puede guardar dos bytes eliminando g=ya que el identificador de función no necesita un nombre para ser un envío válido.
Alex A.
10

kdb + , 3 bytes

dev

Uno de los derivados de APL tenía que tener esto como incorporado.

Prueba de funcionamiento

q)dev 56, 54, 89, 87
16.53028
q)f:dev
q)f 10035, 436844, 42463, 44774
175656.8
q)f 45,67,32,98,11,3
32.53033
Dennis
fuente
8

Dyalog APL, 24 23 21 20 19 17 bytes

*∘.5∘M×⍨-M×M←+/÷≢

Esto define un tren de funciones monádicas sin nombre, que es equivalente a la siguiente función.

{.5*⍨M(×⍨⍵)-M⍵×(M←{(+/⍵)÷≢⍵})⍵}

Pruébelos en línea en TryAPL .

Cómo funciona

El código consta de varios trenes.

M←+/÷≢

Esto define un tren monádico de 3 (horquilla) Mque ejecuta +/(suma de todos los elementos) y (longitud) para el argumento correcto, luego aplica ÷(división) a los resultados, devolviendo la media aritmética de la entrada.

M×M

Esta es otra bifurcación que se aplica Mal argumento correcto, repite esto por segunda vez y aplica ×(producto) a los resultados, devolviendo μ 2 .

×⍨-(M×M)

Esta es otra bifurcación que calcula el cuadrado de la media aritmética como se explicó anteriormente, aplica ×⍨(producto consigo mismo) al argumento correcto y finalmente aplica -(diferencia) a los resultados.

Para la entrada (x 1 , ..., x N ) , esta función devuelve (x 1 - μ 2 , ..., x N - μ 2 ) .

*∘.5∘M

Esta función compuesta se aplica Ma su argumento correcto, entonces *∘.5. Este último utiliza el argumento correcto curry para aplicar la entrada del mapa aa a*0.5(raíz cuadrada de a).

(*∘.5∘M)(×⍨-(M×M))

Finalmente, tenemos este 2-tren monádico (arriba), que aplica primero la función derecha, luego la izquierda a su resultado, calculando la desviación estándar de la siguiente manera.

fórmula

Dennis
fuente
5

R, 41 40 39 36 30 28 bytes

código

Gracias a Beaker , Alex A. y MickyT por muchos bytes.

cat(sd(c(v=scan(),mean(v))))   

códigos antiguos

v=scan();n=length(v);sd(v)/(n/(n-1))**0.5
m=scan();cat(sqrt(sum(mean((m-mean(m))^2))))
m=scan();cat(mean((m-mean(m))^2)^.5) 

Esto debería producir la desviación estándar de la población.

Mutador
fuente
1
No sé R, pero ¿sería posible aumentar la matriz de entrada con la media de la matriz? Parece que podría ser más corto.
vaso de precipitados
1
En este sitio, generalmente no podemos asumir un entorno REPL a menos que la pregunta lo permita explícitamente. Por lo tanto, en este caso, deberá usar catpara imprimir en la consola.
Alex A.
1
Además, R usa ^para exponenciación, que es un byte más corto que **.
Alex A.
1
No necesita sumar la media ya que meandevuelve un escalar; sumno tiene efecto. 36 bytes:x=scan();cat(mean((x-mean(x))^2)^.5)
Alex A.
1
@ AndréMuta se disculpa, cuando lo probé tenía una X dando vueltas.
MickyT
5

Pyth, 20 19 17 13 bytes

@.O^R2-R.OQQ2

¡Gracias a @FryAmTheEggman por jugar golf en 4 bytes!

Pruébalo en línea.

Cómo funciona

        .OQ    Compute the arithmetic mean of the input (Q).
      -R   Q   Subtract the arithmetic mean of all elements of Q.
   ^R2         Square each resulting difference.
 .O            Compute the arithmetic mean of the squared differences.
@           2  Apply square root.
Dennis
fuente
Me gusta cómo la descomposición de un programa Pyth parece una parábola sesgada.
Conor O'Brien
5

CJam, 24 22 21 bytes

q~_,_@_:+d@/f-:mh\mq/

¡Gracias a @aditsu por jugar golf en 1 byte!

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

q~                    e# Read all input and evaluate it.
  _,                  e# Copy the array and push its length.
    _@                e# Copy the length and rotate the array on top.
      _:+d            e# Copy the array and compute its sum. Cast to Double.
          @/          e# Rotate the length on top and divide the sum by it.
            f-        e# Subtract the result (μ) from the array's elements.
              :mh     e# Reduce by hypotenuse.
                      e# a b mh -> sqrt(a^2 + b^2)
                      e# sqrt(a^2 + b^2) c mh -> sqrt(sqrt(a^2 + b^2)^2 + c^2)
                      e#                           = sqrt(a^2 + b^2 + c^2)
                      e# ⋮
                 \mq/ e# Divide the result by the square root of the length.
Dennis
fuente
Creo que puedes convertir solo la longitud al doble
aditsu
@aditsu Por supuesto. ¡Gracias!
Dennis
55
:mhes genial por cierto :)
Aditsu
2
Reduce by hypotenuse.No es algo que ves todos los días.
lirtosiast
4

APL, 24 bytes

{.5*⍨+/(2*⍨⍵-+/⍵÷≢⍵)÷≢⍵}

Un enfoque un poco diferente al de la solución Dyalog APL de Dennis . Esto debería funcionar con cualquier implementación de APL.

Esto crea una función monádica sin nombre que calcula el vector ( x - µ ) 2 ya que 2*⍨⍵-+/⍵÷≢⍵, divide esto por N ( ÷≢⍵), toma la suma de este vector usando+/ , y luego toma la raíz cuadrada ( .5*⍨).

Pruébalo en línea

Alex A.
fuente
No todas las implementaciones APL apoya {dfns }, o . Sin embargo, todas las versiones son compatiblesR←F Y R←(+/((Y-+/Y÷⍴Y)*2)÷⍴Y)*.5
Adám
4

Julia, 26 19 bytes

x->std([x;mean(x)])

Esto crea una función sin nombre que acepta una matriz y devuelve un flotante.

Sin golf, supongo:

function f(x::Array{Int,1})
    # Return the sample standard deviation (denominator N-1) of
    # the input with the mean of the input appended to the end.
    # This corrects the denominator to N without affecting the
    # mean.
    std([x; mean(x)])
end
Alex A.
fuente
4

TI-BASIC, 7 bytes

stdDev(augment(Ans,{mean(Ans

Tomé prestado el algoritmo para obtener la desviación estándar de la población de la desviación estándar de la muestra desde aquí .

La solución más corta que pude encontrar sin augment(es de 9 bytes:

stdDev(Ans√(1-1/dim(Ans
Thomas Kwa
fuente
Estoy de acuerdo con AndréMuta, esto no produce el resultado requerido, mira aquí.
flawr
1
@ AndréMuta @flawr El TI incorporado stdDev(calcula la muestra SD; stdDev(augment(Ans,{mean(Anscalcula la población SD. Eso está en la página a la que te vinculaste.
lirtosiast
3

Haskell, 61 bytes

d n=1/sum(n>>[1])
f a=sqrt$d a*sum(map((^2).(-)(d a*sum a))a)

Directo, excepto tal vez mi función de longitud personalizada sum(n>>[1]) para engañar al estricto sistema de tipos de Haskell.

nimi
fuente
Puedes usar sum(1<$n)y <$>para map.
Laikoni
Se me ocurrió que esas funciones podrían no estar presentes debido a una versión anterior de GHC en el momento de esta respuesta, pero de acuerdo con este consejo , se introdujeron como preludio en marzo de 2015, y la política del sitio ha cambiado de todos modos para permitir un lenguaje más nuevo caracteristicas.
Laikoni
3

Python 3.4+, 30 bytes

from statistics import*;pstdev

Importa la función integrada pstdev, p. Ej.

>>> pstdev([56,54,89,87])
16.53027525481654
Sp3000
fuente
Creo que justo pstdevdespués de la primera línea está bien? Creo que xnor hizo eso hace un tiempo con sum. Tiene sentido wrt cómo se usarían lambdas anónimas, es decir, p=pstdevomap(pstdev, [...])
FryAmTheEggman
Iba a decir lo mismo. Las publicaciones meta parecen admitir simplemente poner una función literal.
xnor
Sin pstdevembargo, creo que todavía necesitas escribir el literal , como from statistics import*;pstdev. De lo contrario, esta podría ser cualquier función de esa biblioteca.
xnor
@xnor Editado. tbh No estoy realmente seguro acerca de la decisión sobre estas situaciones ...
Sp3000
Tal vez una meta pregunta sería útil? :)
Decaimiento Beta
2

JavaScript (ES6), 73 bytes

a=>Math.sqrt(a.reduce((b,c)=>b+(d=c-eval(a.join`+`)/(l=a.length))*d,0)/l)
Mwr247
fuente
@BetaDecay En cuanto a la precisión de la salida? Mi original en realidad no tenía eso correcto, y lo arreglé justo después, solo para descubrir que el punto flotante estaba bien, jeje ... Entonces, ¿está bien ahora como está?
Mwr247
Sí, está bien :)
Beta Decay
77
Psst ... puedes ahorrar 5 bytes usando este método de suma en eval(a.join`+`)lugar de a.reduce((e,f)=>e+f)
George Reith
@GeorgeReith ¡Buen truco! Voy a tener que recordar eso para más tarde ...
Mwr247
2

Gelatina , no competidora

11 bytes Esta respuesta no es competitiva, ya que utiliza un lenguaje posterior al desafío.

S÷L
Dz_²ÇN½

Esta es una traducción directa de mi respuesta APL a Jelly. Pruébalo en línea!

Cómo funciona

S÷L        Helper link. Argument: z (vector)

S          Compute the sum of z.
  L        Compute the length of z.
 ÷         Divide the former by the latter.
           This computes the mean of z.

Dz_²ÇN½    Main link. Argument: z (vector)

Ç          Apply the previous link, i.e., compute the mean of z.
 ²         Square the mean.
   ²       Square all number in z.
  _        Subtract each squared number from the squared mean.
    Ç      Take the mean of the resulting vector.
     N     Multiply it by -1.
      ½    Take the square root of the result.
Dennis
fuente
2

J, 18 bytes

[:%:@M*:-M*M=:+/%#

Esta es una traducción directa de mi respuesta APL a J.

Pruébalo en línea!

Dennis
fuente
No tenía idea de que Mhabía un predefinido incorporado.
Conor O'Brien
No lo es M=:+/%#es una definición de función en línea.
Dennis
Pero está predefinido, ¿verdad? Quizás construir es el término equivocado
Conor O'Brien
No, no está predefinido. M=:+/%#guarda el verbo +/%#en M, luego lo llama.
Dennis
Lo siento XD, no vi la última parte
Conor O'Brien
1

Simplex v.0.5 , 43 bytes

Solo porque. Realmente necesito jugar golf este byte más.

t[@u@RvR]lR1RD@wA@T@{j@@SR2ERpR}u@vR@TR1UEo   
t[      ]                                     ~~ Applies inner function to entire strip (left-to-right)
  @                                           ~~ Copies current value to register
   u                                          ~~ Goes up a strip level
    @                                         ~~ Dumps the register on the current byte
     R                                        ~~ Proceeds right (s1)
      v                                       ~~ Goes back down
       R                                      ~~ Proceeds right (s0)
                                              ~~ Go right until an empty byte is found
         lR1RD                                ~~ Push length, 1, and divide.
              @                               ~~ Store result in register (1/N)
               wA                             ~~ Applies A (add) to each byte, (right-to-left)
                 @T@                          ~~ Puts 1/N down, multiplies it, and copies it to the register
                    {          }              ~~ Repeats until a zero-byte is met
                     j@@                      ~~ inserts a new byte and places register on it
                        SR                    ~~ Subtract it from the current byte and moves right
                          2E                  ~~ Squares result
                            RpR               ~~ Moves to the recently-created cell, deletes it, and continues
                                u@v           ~~ takes 1/N again into register
                                   R@T        ~~ multiplies it by the new sum
                                      R1UE    ~~ takes the square root of previous
                                          o   ~~ output as number
Conor O'Brien
fuente
1

Prólogo (SWI), 119 bytes

Código:

q(U,X,A):-A is(X-U)^2.
p(L):-sumlist(L,S),length(L,I),U is S/I,maplist(q(U),L,A),sumlist(A,B),C is sqrt(B/I),write(C).

Explicación:

q(U,X,A):-A is(X-U)^2.   % calc squared difference of X and U
p(L):-sumlist(L,S),      % sum input list
      length(L,I),       % length of input list
      U is S/I,          % set U to the mean value of input list
      maplist(q(U),L,A), % set A to the list of squared differences of input and mean
      sumlist(A,B),      % sum squared differences list
      C is sqrt(B/I),    % divide sum of squares by length of list
      write(C).          % print answer

Ejemplo:

p([10035, 436844, 42463, 44774]).
175656.78441352615

Pruébelo en línea aquí

Emigna
fuente
1

Perl5, 39 38


 16 para el script
+22 para el Mswitch
+ 1 para el Eswitch
= 39

perl -MStatistics::Lite=:all -E"say stddevp@ARGV" .1 .2 300

Probado en fresa 5.20.2.


Ah, pero luego me di cuenta de que dijiste que nuestras respuestas pueden ser funciones en lugar de programas. En ese caso,

{use Statistics::Lite":all";stddevp@_}

solo tiene 38. Probado en Strawberry 5.20.2 como

print sub{use Statistics::Lite":all";stddevp@_}->( .1, .2, 300)
msh210
fuente
0

Python, 57 bytes

lambda l:(sum((x-sum(l)/len(l))**2for x in l)/len(l))**.5

Toma la entrada como una lista

Gracias @xnor

Decaimiento Beta
fuente
Creo que puede hacerlo .5en lugar de 0.5guardar un byte. ¿También quieres decir en len(x)lugar de len(l)?
Alex A.
@AlexA. Uhh, no, no lo creo ...
Beta Decay
1
Lo siento, me confundí. No tenga en cuenta el xy lsin sentido. Pero aún puede hacer .5para guardar un byte.
Alex A.
1
@BetaDecay Es más corto para utilizar una lista borrador de asignar una lambda: sum((x-sum(l)/len(l))**2for x in l).
xnor
1
Una formulación diferente dio la misma longitud: lambda l:(sum(x*x*len(l)for x in l)-sum(l)**2)**.5/len(l).
xnor
0

PowerShell, 122

:\>type stddev.ps1
$y=0;$z=$args -split",";$a=($z|?{$_});$c=$a.Count;$a|%{$y+=$_};$b=$y/$c;$a|%{$x+
=(($_-$b)*($_-$b))/$c};[math]::pow($x,0.5)

explicación

<#
$y=0                            init
$z=$args -split","              split delim ,
$a=($z|? {$_})                  remove empty items
$c=$a.Count                     count items
$a|%{$y+=$_}                    sum
$b=$y/$c                        average
$a|%{$x+=(($_-$b)*($_-$b))/$c}  sum of squares/count
[math]::pow($x,0.5)             result
#>

resultado

:\>powershell -nologo -f stddev.ps1 45,67,32,98,11,3
32.5303277300156

:\>powershell -nologo -f stddev.ps1 45,  67,32,98,11,3
32.5303277300156

:\>powershell -nologo -f stddev.ps1 45,  67,32, 98 ,11,3
32.5303277300156

:\>powershell -nologo -f stddev.ps1 10035, 436844, 42463, 44774
175656.784413526

:\>powershell -nologo -f stddev.ps1 1,1,1,1,1,1
0
blabb
fuente
0

Fortran, 138 bytes

Solo una implementación directa de la ecuación en Fortran:

double precision function std(x)
integer,dimension(:),intent(in) :: x
std = norm2(dble(x-sum(x)/size(x)))/sqrt(dble(size(x)))
end function
Time Laird
fuente
0

SmileBASIC, 105 bytes (como función)

Acabo de notar que está permitido que sea una función. Vaya, eso reduce mi respuesta dramáticamente. Esto define una función Sque toma una matriz y devuelve la desviación estándar de la población. Ve a leer el otro para obtener una explicación, pero omite la parte de análisis. No quiero volver a hacerlo.

DEF S(L)N=LEN(L)FOR I=0TO N-1U=U+L[I]NEXT
U=1/N*U FOR I=0TO N-1T=T+POW(L[I]-U,2)NEXT RETURN SQR(1/N*T)END

Como programa, 212 bytes

Desafortunadamente, tengo que tomar la lista de entrada como una cadena y analizarla yo mismo. Esto agrega más de 100 bytes a la respuesta, por lo que si se permite algún formato de entrada que no sea una lista separada por comas, me encantaría escucharlo. También tenga en cuenta que porqueVAL tiene errores, tener un espacio antes de la coma o arrastrar la cadena rompe el programa. Después de la coma o al comienzo de la cadena está bien.

DIM L[0]LINPUT L$@L I=INSTR(O,L$,",")IF I>-1THEN PUSH L,VAL(MID$(L$,O,I-O))O=I+1GOTO@L ELSE PUSH L,VAL(MID$(L$,O,LEN(L$)-O))
N=LEN(L)FOR I=0TO N-1U=U+L[I]NEXT
U=1/N*U FOR I=0TO N-1T=T+POW(L[I]-U,2)NEXT?SQR(1/N*T)

Ungolfed y explicó:

DIM L[0]  'define our array
LINPUT L$ 'grab string from input

'parse list
'could've used something cleaner, like a REPEAT, but this was shorter
@L
I=INSTR(O,L$,",")                 'find next comma
IF I>-1 THEN                      'we have a comma
 PUSH L,VAL(MID$(L$,O,I-O))       'get substring of number, parse & store
 O=I+1                            'set next search location
 GOTO @L                          'go again
ELSE                              'we don't have a comma
 PUSH L,VAL(MID$(L$,O,LEN(L$)-O)) 'eat rest of string, parse & store
ENDIF                             'end

N=LEN(L) 'how many numbers we have

'find U
'sum all of the numbers, mult by 1/N
FOR I=0 TO N-1
 U=U+L[I]
NEXT
U=1/N*U

'calculate our popstdev
'sum(pow(x-u,2))
FOR I=0 TO N-1
 T=T+POW(L[I]-U,2)
NEXT
PRINT SQR(1/N*T) 'sqrt(1/n*sum)
caracol_
fuente
0

Axioma, 137 bytes

m(a:List Float):Complex Float==(#a=0=>%i;reduce(+,a)/#a)
s(a:List Float):Complex Float==(#a=0=>%i;n:=m(a);sqrt(m([(x-n)^2 for x in a])))

La función m () devolvería la media de la lista en la entrada. Ambas funciones en caso de error devuelven% i la constante imaginaria sqrt (-1). Código de prueba y resultados. [pero el resultado si está bien, es la parte real de un número complejo]

(6) -> s([45,67,32,98,11,3])
   (6)  32.5303277300 15604966

(7) -> s([10035,436844,42463,44774])
   (7)  175656.7844135261 4035

(8) -> s([1,1,1,1,1,1])
   (8)  0.0
RosLuP
fuente
0

Python 3 , 49 bytes

lambda l,N:(sum((i-sum(l)/N)**2for i in l)/N)**.5

Pruébalo en línea!

Toma luna lista de enteros y Nla cantidad de enteros presentes.

musicman523
fuente
0

Pyt , 13 bytes

←Đ↔Ł↔е-²Ʃ⇹/√

Implementa la fórmula para la desviación estándar.

mudkip201
fuente