부동 소수점 숫자의 목록이 주어지면 있으면이를 표준화하십시오 .

세부

• 모든 값 의 평균 이 0이고 표준 편차 가 1 이면 리스트 $x_1,x_2,\ldots,x_n$ 이 표준화 됩니다. 이를 계산하는 한 가지 방법은 먼저 평균 μ 와 표준 편차 σ 를 μ =로 계산하는 것입니다. 1$\mu$$\sigma$ $$\mu = \frac1n\sum_{i=1}^n x_i \qquad \sigma = \sqrt{\frac{1}{n}\sum_{i=1}^n (x_i -\mu)^2} ,$$ 모든$x_i$를xi−μ로 바꾸어 표준화 계산$\frac{x_i-\mu}{\sigma}$ .
• 입력에 두 개 이상의 별개의 항목이 포함되어 있다고 가정 할 수 있습니다 ( $\sigma \neq 0$ 을 의미 ).
• 일부 구현에서는 여기서 사용 하는 모집단 표준 편차 $\sigma$ 같지 않은 샘플 표준 편차 를 사용합니다.
• 있습니다 CW 응답 모든 사소한 솔루션 .

예

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

(이 예제는 이 스크립트 로 생성되었습니다 .)

R , 51 45 38 37 바이트

주세페와 J.Doe에게 감사합니다!

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

온라인으로 사용해보십시오!

모든 사소한 항목에 대한 CW

Python 3 + scipy, 31 바이트

from scipy.stats import*
zscore

온라인으로 사용해보십시오!

옥타브 / MATLAB, 15 바이트

@(x)zscore(x,1)

온라인으로 사용해보십시오!

APL (Dyalog Classic) , 21 20 19 바이트

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

온라인으로 사용해보십시오!

⊢÷⌹ 제곱의 합입니다

⊢÷⌹×≢ 길이로 나눈 제곱의 합입니다.

MATL , 10 바이트

tYm-t&1Zs/

온라인으로 사용해보십시오!

설명

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 바이트

Erik 덕분에 9 바이트 절약 + ngn 덕분에 2 개 더 절약

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

숫자 벡터를 요구하고 입력 표준의 평균 표준 편차 및 표준화 된 요소를 계산합니다.

R + pryr, 53 52 바이트

@Robert S.의 솔루션 sum(x|1)대신에 -1 바이트 사용length(x)

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

통계학자를 위해 만들어진 언어이기 때문에 이것이 내장 함수가 없다는 사실에 놀랐습니다. 적어도 내가 찾을 수있는 것은 아닙니다. 함수조차도 mosaic::zscore예상되는 결과를 얻지 못합니다. 샘플 표준 편차 대신 모집단 표준 편차를 사용하기 때문일 수 있습니다.

온라인으로 사용해보십시오!

Tcl , 126 바이트

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

온라인으로 사용해보십시오!

Jelly, 10 bytes

_ÆmµL½÷ÆḊ×

Try it online!

더 짧지는 않지만 Jelly의 결정 함수 ÆḊ는 벡터 표준을 계산합니다.

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

Mathematica, 25 바이트

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

순수한 기능. 숫자 목록을 입력으로 사용하고 기계 정밀 숫자 목록을 출력으로 반환합니다. 내장 Standardize함수는 기본적으로 샘플 분산을 사용합니다.

J , 22 바이트

Cows ck 덕분에 -1 바이트!

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

온라인으로 사용해보십시오!

J , 31 23 바이트

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

온라인으로 사용해보십시오!

                   +/%# - 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 바이트

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

@ngn 덕분에 -4 바이트

온라인으로 사용해보십시오!

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

Thanks to @flawr for the suggestions to use sum(1<$x) instead of sum[1|_<-x] and to inline the mean, @xnor for inlining the standard deviation and other reductions.

Expanded:

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

▓-_²▓√/

Try it online!

Explanation

This is literally a byte-for-byte recreation of Kevin Cruijssen's 05AB1E answer, but I save some bytes from MathGolf having 1-byters for everything needed for this challenge. Also the answer looks quite good in my opinion!

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

Try it online!

Commented

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*

Try it online!

Haskell, 59 bytes

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

Try it online!

Doesn't use libraries.

The helper function % computes the sum of ith powers of a list, which lets us get three useful values.

• 0%l is the length of l (call this n)
• 1%l is the sum of l (call this s)
• 2%l is the sum of squares of l (call this m)

We can express the z-score of an element y as

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

(This is the expression (y-s/n)/sqrt(v/n-(s/n)^2) simplified a bit by multiplying the top and bottom by n.)

We can insert the expressions 0%l, 1%l, 2%l without parens because the % we define has higher precedence than the arithmetic operators.

(%)i=sum.map(^i) is the same length as i%l=sum.map(^i)l. Making it more point-free doesn't help. Defining it like g i=... loses bytes when we call it. Although % works for any list but we only call it with the problem input list, there's no byte loss in calling it with argument l every time because a two-argument call i%l is no longer than a one-argument one g i.

K (oK), 33 23 bytes

-10 bytes thanks to ngn!

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

Try it online!

First attempt at coding (I don't dare to name it "golfing") in K. I'm pretty sure it can be done much better (too many variable names here...)

MATLAB, 26 bytes

Trivial-ish, std(,1) for using population standard deviation

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

TI-Basic (83 series), 14 11 bytes

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

Takes input in Ans. For example, if you type the above into prgmSTANDARD, then {1,2,3}:prgmSTANDARD will return {-1.224744871,0.0,1.224744871}.

Previously, I tried using the 1-Var Stats command, which stores the population standard deviation in σx, but it's less trouble to compute it manually.

05AB1E, 9 bytes

ÅA-DnÅAt/

Port of @Arnauld's JavaScript answer, so make sure to upvote him!

Try it online or verify all test cases.

Explanation:

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

Jelly, 10 bytes

_Æm÷²Æm½Ɗ$

Try it online!

Pyth, 21 19 bytes

mc-dJ.OQ@.Om^-Jk2Q2

Try it online here.

mc-dJ.OQ@.Om^-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

Edit: after seeing Kevin's answer, changed to use the average builtin for the inner results. Previous answer: 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)

Try it online!

Link is to a functional version of the code which constructs an array from STDIN given its length and then its elements, then runs the function Z on that, and finally prints out the values.

Defines a function Z which returns an array.

The 1. on line 4 is necessary to do the floating point arithmetic properly.

Julia 0.7, 37 bytes

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

Try it online!

Charcoal, 25 19 bytes

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

Try it online! Link is to verbose version of code. Explanation:

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

Calculate $\mu$ and vectorised subtract it from each $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.

Calculate $\sigma$, vectorised divide each $x_i$ by it, and output the result.

Edit: Saved 6 bytes thanks to @ASCII-only for a) using SquareRoot() instead of Power(0.5) b) fixing vectorised Divide() (it was doing IntDivide() instead) c) making Power() vectorise.