Dada una lista de números de coma flotante, estandarícela .

Detalles

• Una lista $x_1,x_2,\ldots,x_n$ está estandarizada si la media de todos los valores es 0, y la desviación estándar es 1. Una forma de calcular esto es calculando primero la media $\mu$ y la desviación estándar $\sigma$ como $$\mu = \frac1n\sum_{i=1}^n x_i \qquad \sigma = \sqrt{\frac{1}{n}\sum_{i=1}^n (x_i -\mu)^2} ,$$ y luego calcular la estandarización reemplazando cada$x_i$con$\frac{x_i-\mu}{\sigma}$ .
• Puede suponer que la entrada contiene al menos dos entradas distintas (lo que implica $\sigma \neq 0$ ).
• Tenga en cuenta que algunas implementaciones usan la desviación estándar de muestra, que no es igual a la desviación estándar de la población $\sigma$ que estamos usando aquí.
• Hay una respuesta CW para todas las soluciones triviales .

Ejemplos

[1,2,3] -> [-1.224744871391589,0.0,1.224744871391589]
[1,2] -> [-1,1]
[-3,1,4,1,5] -> [-1.6428571428571428,-0.21428571428571433,0.8571428571428572,-0.21428571428571433,1.2142857142857144]

(Estos ejemplos se han generado con este script ).

R , 51 45 38 37 bytes

Gracias a Giuseppe y J.Doe!

function(x)scale(x)/(1-1/sum(x|1))^.5

Pruébalo en línea!

CW para todas las entradas triviales

Python 3 + scipy, 31 bytes

from scipy.stats import*
zscore

Pruébalo en línea!

Octava / MATLAB, 15 bytes

@(x)zscore(x,1)

Pruébalo en línea!

APL (Dyalog Classic) , 21 20 19 bytes

(-÷.5*⍨⊢÷⌹×≢)+/-⊢×≢

Pruébalo en línea!

⊢÷⌹ es suma de cuadrados

⊢÷⌹×≢ es la suma de cuadrados dividida por la longitud

MATL , 10 bytes

tYm-t&1Zs/

Pruébalo en línea!

Explicación

t       % Implicit input
        % Duplicate
Ym      % Mean
-       % Subtract, element-wise
t       % Duplicate
&1Zs    % Standard deviation using normalization by n
/       % Divide, element-wise
        % Implicit display

APL + WIN, 41,32 30 bytes

9 bytes guardados gracias a Erik + 2 más gracias a ngn

x←v-(+/v)÷⍴v←⎕⋄x÷(+/x×x÷⍴v)*.5

Solicita el vector de números y calcula la desviación estándar media y los elementos estandarizados del vector de entrada

R + pryr, 53 52 bytes

-1 byte usando en sum(x|1)lugar de length(x)como se ve en la solución de @Robert S.

pryr::f((x-(y<-mean(x)))/(sum((x-y)^2)/sum(x|1))^.5)

Por ser un lenguaje creado para estadísticos, me sorprende que esto no tenga una función incorporada. Al menos no uno que pude encontrar. Incluso la función mosaic::zscoreno produce los resultados esperados. Esto probablemente se deba al uso de la desviación estándar de la población en lugar de la desviación estándar de la muestra.

Pruébalo en línea!

Tcl , 126 bytes

proc S L {lmap c $L {expr ($c-[set m ([join $L +])/[set n [llength $L]].])/sqrt(([join [lmap c $L {expr ($c-$m)**2}] +])/$n)}}

Pruébalo en línea!

Jalea , 10 bytes

_ÆmµL½÷ÆḊ×

Pruébalo en línea!

No es más corto, pero la función determinante de Jelly ÆḊtambién calcula la norma vectorial.

_Æm             x - mean(x)
   µ            then:
    L½          Square root of the Length
      ÷ÆḊ       divided by the norm
         ×      Multiply by that value

Mathematica, 25 bytes

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

Pura función. Toma una lista de números como entrada y devuelve una lista de números de precisión de máquina como salida. Tenga en cuenta que la Standardizefunción integrada utiliza la varianza de muestra de forma predeterminada.

J , 22 bytes

-1 byte gracias a Cows quack!

(-%[:%:1#.-*-%#@[)+/%#

Pruébalo en línea!

J , 31 23 bytes

(-%[:%:#@[%~1#.-*-)+/%#

Pruébalo en línea!

                   +/%# - mean (sum (+/) divided (%) by the number of samples (#)) 
(                 )     - the list is a left argument here (we have a hook)
                 -      - the difference between each sample and the mean
                *       - multiplied by 
               -        - the difference between each sample and the mean
            1#.         - sum by base-1 conversion
          %~            - divided by
       #@[              - the length of the samples list
     %:                 - square root
   [:                   - convert to a fork (function composition) 
 -                      - subtract the mean from each sample
  %                     - and divide it by sigma

APL (Dyalog Unicode) , 33 29 bytes

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

-4 bytes gracias a @ngn

Pruébalo en línea!

Haskell, 80 75 68 bytes

t x=k(/sqrt(f$sum$k(^2)))where k g=g.(-f(sum x)+)<$>x;f=(/sum(1<$x))

Gracias a @flawr por las sugerencias para usar en sum(1<$x)lugar de sum[1|_<-x]e incluir la media, @xnor por incluir la desviación estándar y otras reducciones.

Expandido:

-- Standardize a list of values of any floating-point type.
standardize :: Floating a => [a] -> [a]
standardize input = eachLessMean (/ sqrt (overLength (sum (eachLessMean (^2)))))
  where

    -- Map a function over each element of the input, less the mean.
    eachLessMean f = map (f . subtract (overLength (sum input))) input

    -- Divide a value by the length of the input.
    overLength n = n / sum (map (const 1) input)

MathGolf , 7 bytes

▓-_²▓√/

Pruébalo en línea!

Explicación

Esto es literalmente una recreación byte por byte de la respuesta 05AB1E de Kevin Cruijssen, pero guardo algunos bytes de MathGolf con 1 byters para todo lo necesario para este desafío. ¡También la respuesta se ve bastante bien en mi opinión!

▓         get average of list
 -        pop a, b : push(a-b)
  _       duplicate TOS
   ²      pop a : push(a*a)
    ▓     get average of list
     √    pop a : push(sqrt(a)), split string to list
      /   pop a, b : push(a/b), split strings

JavaScript (ES7),  80  79 bytes

a=>a.map(x=>(x-g(a))/g(a.map(x=>(x-m)**2))**.5,g=a=>m=eval(a.join`+`)/a.length)

Pruébalo en línea!

Comentado

a =>                      // given the input array a[]
  a.map(x =>              // for each value x in a[]:
    (x - g(a)) /          //   compute (x - mean(a)) divided by
    g(                    //   the standard deviation:
      a.map(x =>          //     for each value x in a[]:
        (x - m) ** 2      //       compute (x - mean(a))²
      )                   //     compute the mean of this array
    ) ** .5,              //   and take the square root
    g = a =>              //   g = helper function taking an array a[],
      m = eval(a.join`+`) //     computing the mean
          / a.length      //     and storing the result in m
  )                       // end of outer map()

Python 3 + numpy , 46 bytes

lambda a:(a-mean(a))/std(a)
from numpy import*

Pruébalo en línea!

Haskell , 59 bytes

(%)i=sum.map(^i)
f l=[(0%l*y-1%l)/sqrt(2%l*0%l-1%l^2)|y<-l]

Pruébalo en línea!

No usa bibliotecas.

La función auxiliar %calcula la suma de las ipotencias de una lista, lo que nos permite obtener tres valores útiles.

• 0%les la longitud de l(llame a esto n)
• 1%les la suma de l(llame a esto s)
• 2%les la suma de cuadrados de l(llame a esto m)

Podemos expresar la puntuación z de un elemento ycomo

(n*y-s)/sqrt(n*v-s^2)

(Esta es la expresión (y-s/n)/sqrt(v/n-(s/n)^2)simplificada un poco al multiplicar la parte superior e inferior por n).

Podemos insertar las expresiones 0%l, 1%l, 2%lsin parens debido a que la %definimos tiene mayor precedencia que los operadores aritméticos.

(%)i=sum.map(^i)tiene la misma longitud que i%l=sum.map(^i)l. Hacerlo más libre de puntos no ayuda. Definirlo como g i=...pierde bytes cuando lo llamamos. Aunque %funciona para cualquier lista, pero solo la llamamos con la lista de entrada del problema, no hay pérdida de bytes al llamarla con argumento lcada vez porque una llamada de dos argumentos i%lno es más larga que una de un argumento g i.

K (oK) , 33 23 bytes

-10 bytes gracias a ngn!

{t%%(+/t*t:x-/x%#x)%#x}

Pruébalo en línea!

Primer intento de codificación (no me atrevo a llamarlo "golf") en K. Estoy bastante seguro de que se puede hacer mucho mejor (demasiados nombres de variables aquí ...)

MATLAB, 26 bytes

Trivial-ish, std(,1)para usar la desviación estándar de la población

f=@(x)(x-mean(x))/std(x,1)

TI-Basic (serie 83), 14 11 bytes

Ans-mean(Ans
Ans/√(mean(Ans²

Toma entrada Ans. Por ejemplo, si escribe lo anterior en prgmSTANDARD, entonces {1,2,3}:prgmSTANDARDvolverá {-1.224744871,0.0,1.224744871}.

Anteriormente, intenté usar el 1-Var Statscomando, que almacena la desviación estándar de la población σx, pero es menos problemático calcularlo manualmente.

05AB1E , 9 bytes

ÅA-DnÅAt/

Puerto de la respuesta de JavaScript de @Arnauld , ¡así que asegúrese de votarlo!

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

ÅA          # Calculate the mean of the (implicit) input
            #  i.e. [-3,1,4,1,5] → 1.6
  -         # Subtract it from each value in the (implicit) input
            #  i.e. [-3,1,4,1,5] and 1.6 → [-4.6,-0.6,2.4,-0.6,3.4]
   D        # Duplicate that list
    n       # Take the square of each
            #  i.e. [-4.6,-0.6,2.4,-0.6,3.4] → [21.16,0.36,5.76,0.36,11.56]
     ÅA     # Pop and calculate the mean of that list
            #  i.e. [21.16,0.36,5.76,0.36,11.56] → 7.84
       t    # Take the square-root of that
            #  i.e. 7.84 → 2.8
        /   # And divide each value in the duplicated list with it (and output implicitly)
            #  i.e. [-4.6,-0.6,2.4,-0.6,3.4] and 2.8 → [-1.6428571428571428,
            #   -0.21428571428571433,0.8571428571428572,-0.21428571428571433,1.2142857142857144]

Jalea , 10 bytes

_Æm÷²Æm½Ɗ$

Pruébalo en línea!

Pyth, 21 19 bytes

[email protected]^-Jk2Q2

Pruébelo en línea aquí .

[email protected]^-Jk2Q2Q   Implicit: Q=eval(input())
                       Trailing Q inferred
    J.OQ               Take the average of Q, store the result in J
           m     Q     Map the elements of Q, as k, using:
             -Jk         Difference between J and k
            ^   2        Square it
         .O            Find the average of the result of the map
        @         2    Square root it
                       - this is the standard deviation of Q
m                  Q   Map elements of Q, as d, using:
  -dJ                    d - J
 c                       Float division by the standard deviation
                       Implicit print result of map

Editar: después de ver la respuesta de Kevin , cambió para usar el promedio incorporado para los resultados internos. Respuesta anterior:mc-dJ.OQ@csm^-Jk2QlQ2

SNOBOL4 (CSNOBOL4) , 229 bytes

	DEFINE('Z(A)')
Z	X =X + 1
	M =M + A<X>	:S(Z)
	N =X - 1.
	M =M / N
D	X =GT(X) X - 1	:F(S)
	A<X> =A<X> - M	:(D)
S	X =LT(X,N) X + 1	:F(Y)
	S =S + A<X> ^ 2 / N	:(S)
Y	S =S ^ 0.5
N	A<X> =A<X> / S
	X =GT(X) X - 1	:S(N)
	Z =A	:(RETURN)

Pruébalo en línea!

Link es a una versión funcional del código que construye una matriz a partir de STDIN dada su longitud y luego sus elementos, luego ejecuta la función Zsobre eso y finalmente imprime los valores.

Define una función Zque devuelve una matriz.

La 1.línea 4 es necesaria para hacer la aritmética de coma flotante correctamente.

Julia 0.7 , 37 bytes

a->(a-mean(a))/std(a,corrected=false)

Pruébalo en línea!

Carbón , 25 19 bytes

≧⁻∕ΣθＬθθＩ∕θ₂∕ΣＸθ²Ｌθ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

       θ    Input array
≧           Update each element
 ⁻          Subtract
   Σ        Sum of
    θ       Input array
  ∕         Divided by
     Ｌ      Length of
      θ     Input array

Calcular μ$\mu$$\mu$ y vectorizado restarlo de cada $x_i$.

  θ         Updated array
 ∕          Vectorised divided by
   ₂        Square root of
     Σ      Sum of
       θ    Updated array
      Ｘ     Vectorised to power
        ²   Literal 2
    ∕       Divided by
         Ｌ  Length of
          θ Array
Ｉ           Cast to string
            Implicitly print each element on its own line.

Calcular $\sigma$, vectorizados dividir cada uno $x_i$ por él, y generar el resultado.

Editar: guardado 6 bytes gracias a @ ASCII-only para a) usar en SquareRoot()lugar de Power(0.5)b) arreglar vectorized Divide()(en su IntDivide()lugar) c) hacer Power()vectorise.