Dato un elenco di numeri in virgola mobile, standardizzarlo .

Dettagli

• Un elenco $x_1,x_2,\ldots,x_n$ è standardizzato se la media di tutti i valori è 0 e la deviazione standard è 1. Un modo per calcolare questo è prima calcolando la media $\mu$ e la deviazione standard $\sigma$ come $$\mu = \frac1n\sum_{i=1}^n x_i \qquad \sigma = \sqrt{\frac{1}{n}\sum_{i=1}^n (x_i -\mu)^2} ,$$ quindi calcolando la standardizzazione sostituendo ogni$x_i$con$\frac{x_i-\mu}{\sigma}$ .
• Si può presumere che l'input contenga almeno due voci distinte (il che implica $\sigma \neq 0$ ).
• Si noti che alcune implementazioni utilizzano la deviazione standard del campione, che non è uguale alla deviazione standard della popolazione $\sigma$ che stiamo utilizzando qui.
• C'è una risposta in CW per tutte le soluzioni banali .

Esempi

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

(Questi esempi sono stati generati con questo script .)

R , 51 45 38 37 byte

Grazie a Giuseppe e J.Doe!

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

Provalo online!

CW per tutte le voci banali

Python 3 + scipy, 31 byte

from scipy.stats import*
zscore

Provalo online!

Octave / MATLAB, 15 byte

@(x)zscore(x,1)

Provalo online!

APL (Dyalog Classic) , 21 20 19 byte

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

Provalo online!

⊢÷⌹ è la somma dei quadrati

⊢÷⌹×≢ è la somma dei quadrati divisi per lunghezza

MATL , 10 byte

tYm-t&1Zs/

Provalo online!

Spiegazione

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 byte

9 byte salvati grazie a Erik + 2 in più grazie a ngn

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

Richiede il vettore di numeri e calcola la deviazione standard media e gli elementi standardizzati del vettore di input

R + pryr, 53 52 byte

-1 byte usando sum(x|1)invece di length(x)come visto nella soluzione di @Robert S.

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

Per essere un linguaggio creato per gli statistici, sono sorpreso che questo non abbia una funzione integrata. Almeno non uno che ho potuto trovare. Anche la funzione mosaic::zscorenon produce i risultati previsti. Ciò è probabilmente dovuto all'uso della deviazione standard della popolazione anziché della deviazione standard del campione.

Provalo online!

Tcl , 126 byte

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

Provalo online!

Gelatina , 10 byte

_ÆmµL½÷ÆḊ×

Provalo online!

Non è più breve, ma la funzione determinante di Jelly ÆḊcalcola anche la norma vettoriale.

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

Mathematica, 25 byte

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

Funzione pura. Prende un elenco di numeri come input e restituisce un elenco di numeri di precisione della macchina come output. Si noti che la Standardizefunzione integrata utilizza la varianza di esempio per impostazione predefinita.

J , 22 byte

-1 byte grazie al ciarlatano Cows!

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

Provalo online!

J , 31 23 byte

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

Provalo online!

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

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

-4 byte grazie a @ngn

Provalo online!

Haskell, 80 75 68 byte

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

Grazie a @flawr per i suggerimenti da utilizzare al sum(1<$x)posto disum[1|_<-x] e per incorporare la media, @xnor per allineare la deviazione standard e altre riduzioni.

Allargato:

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

▓-_²▓√/

Provalo online!

Spiegazione

Questa è letteralmente una ricreazione byte per byte della risposta 05AB1E di Kevin Cruijssen, ma salvo alcuni byte da MathGolf con 1 byte per tutto il necessario per questa sfida. Anche la risposta sembra abbastanza buona secondo me!

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

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

Provalo online!

Commentate

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 byte

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

Provalo online!

Haskell , 59 byte

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

Provalo online!

Non usa le librerie.

La funzione helper %calcola la somma dei ipoteri di un elenco, che ci consente di ottenere tre valori utili.

• 0%lè la lunghezza di l(chiama questo n)
• 1%lè la somma di l(chiama questo s)
• 2%lè la somma dei quadrati di l(chiama questo m)

Possiamo esprimere il punteggio z di un elemento ycome

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

(Questa è l'espressione (y-s/n)/sqrt(v/n-(s/n)^2)semplificata un po 'moltiplicando la parte superiore e inferiore per n.)

Siamo in grado di inserire le espressioni 0%l, 1%l, 2%lsenza parentesi perché il %definiamo ha precedenza maggiore rispetto gli operatori aritmetici.

(%)i=sum.map(^i)è della stessa lunghezza di i%l=sum.map(^i)l. Renderlo più privo di punti non aiuta. Definirlo come g i=...perde byte quando lo chiamiamo. Sebbene %funzioni per qualsiasi elenco ma lo chiamiamo solo con l'elenco di input del problema, non c'è alcuna perdita di byte nel chiamarlo con argomento logni volta perché una chiamata a due argomenti i%lnon è più lunga di una a argomento singolo g i.

K (oK) , 33 23 byte

-10 byte grazie a ngn!

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

Provalo online!

Primo tentativo di codifica (non oso chiamarlo "golf") in K. Sono abbastanza sicuro che possa essere fatto molto meglio (troppi nomi di variabili qui ...)

MATLAB, 26 byte

Trivial-ish, std(,1)per l'utilizzo della deviazione standard della popolazione

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

TI-Basic (serie 83), 14 11 byte

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

Riceve input Ans. Ad esempio, se si digita quanto sopra in prgmSTANDARD, quindi {1,2,3}:prgmSTANDARDverrà restituito {-1.224744871,0.0,1.224744871}.

In precedenza, ho provato a utilizzare il 1-Var Stats comando, che memorizza la deviazione standard della popolazione σx, ma è meno complicato calcolarlo manualmente.

05AB1E , 9 byte

ÅA-DnÅAt/

Porto di risposta JavaScript @Arnauld , quindi assicurati di votarlo!

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Gelatina , 10 byte

_Æm÷²Æm½Ɗ$

Provalo online!

Pyth, 21 19 byte

mc-dJ.OQ@.Om^-Jk2Q2

Provalo online qui .

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

Modifica: dopo aver visto la risposta di Kevin , è stato modificato per utilizzare l'integrale medio per i risultati interni. Risposta precedente:mc-dJ.OQ@csm^-Jk2QlQ2

SNOBOL4 (CSNOBOL4) , 229 byte

	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)

Provalo online!

Il collegamento è a una versione funzionale del codice che costruisce un array da STDIN data la sua lunghezza e quindi i suoi elementi, quindi esegue la funzione Zsu quello e infine stampa i valori.

Definisce una funzione Zche restituisce un array.

La 1.linea 4 è necessaria per eseguire correttamente l'aritmetica in virgola mobile.

Julia 0,7 , 37 byte

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

Provalo online!

Carbone , 25 19 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

Calcolare $\mu$ e vettorializzare sottrarre da ciascuno $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.

Calcolare $\sigma$, diviso in vettori ciascuno $x_i$ da esso e produce il risultato.

Modifica: salvato 6 byte grazie a @ ASCII-solo per a) usando SquareRoot()invece di Power(0.5)b) correggendo vettorializzato Divide()(invece stava facendo IntDivide()) c) rendendo Power()vettorializzato.