Kayan nokta sayılarının bir listesi verildiğinde, standardize edin .

ayrıntılar

• Bir liste olan standart , eğer ortalama tüm değerlerin 0 ve standart sapma , bu hesaplamak için 1. Bir yol tarafından ortalama işlem ilk ve standart sapma olarak ve sonra her yerine koyarak standartlaştırmanın hesaplanması .$x_1,x_2,\ldots,x_n$$\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$$\frac{x_i-\mu}{\sigma}$
• Girdinin en az iki ayrı girdi içerdiğini varsayabilirsiniz (ki bu anlamına gelir ).$\sigma \neq 0$
• Bazı uygulamaların, burada kullandığımız popülasyon standart sapmasına eşit olmayan örnek standart sapmasını kullandığını unutmayın .$\sigma$
• Tüm önemsiz çözümler için bir CW cevabı var .

Örnekler

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

(Bu örnekler bu komut dosyasıyla oluşturulmuştur .)

R , 51 45 38 37 bayt

Giuseppe ve J.Doe sayesinde!

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

Çevrimiçi deneyin!

Tüm önemsiz girişler için CW

Python 3 + scipy, 31 bayt

from scipy.stats import*
zscore

Çevrimiçi deneyin!

Oktav / MATLAB, 15 bayt

@(x)zscore(x,1)

Çevrimiçi deneyin!

APL (Dyalog Klasik) , 21 20 19 bayt

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

Çevrimiçi deneyin!

⊢÷⌹ karelerin toplamı

⊢÷⌹×≢ karelerin toplamının uzunluğa bölünmesiyle elde edilen

MATL , 10 bayt

tYm-t&1Zs/

Çevrimiçi deneyin!

açıklama

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 bayt

Erik sayesinde 2 bayt tasarruf + ngn sayesinde 2 daha fazla

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

Sayıların vektörü için istemler ve ortalama standart sapmayı ve girdi vektörünün standartlaştırılmış elemanlarını hesaplar

R + pryr, 53 52 bayt

-1 bayt kullanılarak sum(x|1)yerine length(x)@Robert S. çözeltisi görüldüğü gibi

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

İstatistikçiler için oluşturulmuş bir dil olduğu için, bunun yerleşik bir işlevi olmadığına şaşırdım. En azýndan bulamadým. İşlev bile mosaic::zscorebeklenen sonuçları vermez. Bunun nedeni muhtemelen örnek standart sapma yerine popülasyon standart sapmasının kullanılmasıdır.

Çevrimiçi deneyin!

Tcl , 126 bayt

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

Çevrimiçi deneyin!

Jöle , 10 bayt

_ÆmµL½÷ÆḊ×

Çevrimiçi deneyin!

Daha kısa değil, ancak Jelly'in belirleyici işlevi ÆḊvektör normunu da hesaplar.

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

Mathematica, 25 bayt

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

Saf fonksiyon. Sayıların bir listesini girdi olarak alır ve makine hassas sayılarının bir listesini çıktı olarak döndürür. Yerleşik Standardizeişlevin varsayılan olarak örnek varyansını kullandığını unutmayın.

J , 22 bayt

İnekler quack sayesinde -1 bayt!

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

Çevrimiçi deneyin!

J , 31 23 bayt

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

Çevrimiçi deneyin!

                   +/%# - 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 bayt

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

@Ngn sayesinde -4 bayt

Çevrimiçi deneyin!

Haskell, 80 75 68 bayt

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

Ortalama sum(1<$x)yerine sum[1|_<-x]satır içi kullanmak ve önerileri kullanmak için @flawr'a teşekkürler , standart sapmayı ve diğer indirimleri satırlamak için @xnor.

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 bayt

▓-_²▓√/

Çevrimiçi deneyin!

açıklama

Bu kelimenin tam anlamıyla Kevin Cruijssen'in 05AB1E cevabının bayt-byte'lık bir rekreasyonudur, ancak MathGolf'un bu meydan okuma için gereken her şey için 1 baytlık bazı baytları kurtarıyorum. Ayrıca cevap bence oldukça iyi görünüyor!

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

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

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

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

Çevrimiçi deneyin!

Haskell , 59 bayt

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

Çevrimiçi deneyin!

Kitaplık kullanmaz.

Yardımcı işlevi , üç yararlı değer elde etmemizi sağlayan bir listenin güçlerinin %toplamını hesaplar i.

• 0%luzunluğu l(buna çağrı n)
• 1%ltoplamıdır l(buna çağrı s)
• 2%lkarelerinin toplamı l(bu çağrı m)

Biz bir elementin Z-skoru ifade edebilir yolarak

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

(Bu, (y-s/n)/sqrt(v/n-(s/n)^2)üst ve alt ile çarpılarak biraz basitleştirilen ifadedir n.)

Biz ifadeleri ekleyebilirsiniz 0%l, 1%l, 2%lçünkü Pars olmadan %biz tanımlamak aritmetik operatörler daha yüksek önceliğe sahiptir.

(%)i=sum.map(^i)ile aynı uzunluktadır i%l=sum.map(^i)l. Daha fazla noktasız hale getirilmesi yardımcı olmaz. Gibi tanımlama g i=...diyoruz zaman bayt kaybeder. %Herhangi bir liste için çalışmasına rağmen, yalnızca sorun giriş listesiyle çağırıyoruz, ancak lher defasında argümanla çağırma bayt kaybı yok çünkü iki argümanlı çağrı i%ltek argümanlı bir listeden daha uzun değil g i.

K (ok) , 33 23 bayt

Ngn sayesinde -10 bayt!

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

Çevrimiçi deneyin!

K kodlama ilk girişimi (ben "golf" olarak adlandırmaya cesaret edemiyorum) K çok daha iyi yapılabilir eminim (burada çok fazla değişken isimleri ...)

MATLAB, 26 bayt

std(,1)Popülasyon standart sapmasını kullanmak için önemsiz-ish

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

TI-Basic (83 serisi), 14 11 bayt

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

Girdi alır Ans. Örneğin, yukarıda yazdığınız takdirde prgmSTANDARD, o zaman {1,2,3}:prgmSTANDARDdönecektir {-1.224744871,0.0,1.224744871}.

Daha önce, 1-Var Statspopülasyon standart sapmasını depolayan komutu kullanmayı denedim σx, ancak manuel olarak hesaplamak daha az sorun.

05AB1E , 9 bayt

ÅA-DnÅAt/

Port of @Arnauld'un JavaScript yanıtı , bu yüzden onu oyladığınızdan emin olun!

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

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

Jöle , 10 bayt

_Æm÷²Æm½Ɗ$

Çevrimiçi deneyin!

Pyth, 21 19 bayt

mc-dJ.OQ@.Om^-Jk2Q2

Burada çevrimiçi deneyin .

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

Düzenleme: Kevin'in cevabını gördükten sonra , iç sonuçlar için ortalama yerleşimi kullanmak üzere değiştirildi. Önceki cevap:mc-dJ.OQ@csm^-Jk2QlQ2

SNOBOL4 (CSNOBOL4) , 229 bayt

	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)

Çevrimiçi deneyin!

Bağlantı, uzunluğuna ve sonra öğelerine göre STDIN'den bir dizi oluşturan kodun işlevsel bir sürümüne, daha sonra bu işlevi çalıştırır Zve son olarak değerleri yazdırır.

ZDizi döndüren bir işlevi tanımlar .

1.On line 4 düzgün kayan noktalı aritmetik yapmak gereklidir.

Julia 0.7 , 37 bayt

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

Çevrimiçi deneyin!

Kömür , 25 19 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

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

$\mu$$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.

$\sigma$$x_i$

Düzenleme: @ için sadece ASCII sayesinde 6 bayt kaydetti- SquareRoot()yerine a) kullanarak Power(0.5)b) vectorized sabitleme Divide()(bunun IntDivide()yerine yapıyordu ) c) Power()vectorise yapma .