[Question]
  [
## Challenge
Given a list of numbers, calculate the population standard deviation of the list.
Use the following equation to calculate population standard deviation:
![](https://upload.wikimedia.org/math/3/1/8/31830fa1f2f922edf6079209a51f8967.png)
## Input
The input will a list of integers in any format (list, string, etc.). Some examples:
```
56,54,89,87
67,54,86,67
```
The numbers will always be integers.
Input will be to STDIN or function arguments.
## Output
The output must be a floating point number.
## Rules
You may use built in functions to find the standard deviation.
Your answer can be either a full program or a function.
## Examples
```
10035, 436844, 42463, 44774 => 175656.78441352615
45,67,32,98,11,3 => 32.530327730015607
1,1,1,1,1,1 => 0.0
```
## Winning
The shortest program or function wins.
## Leaderboard
```
var QUESTION_ID=60901,OVERRIDE_USER=30525;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
  
[Answer]
# [Clip](https://esolangs.org/wiki/Clip), 3
```
.sk
```
`.s` is the standard deviation, `k` parses the input in the form `{1,2,3}`.
[Answer]
# Mathematica, ~~24~~ 22 bytes
Nice, Mathematica has a built-in `StandardDevi...` oh... that computes the sample standard deviation, not the population standard deviation.
But what if we use `Variance`... oh... same deal.
But there is yet another related built-in:
```
CentralMoment[#,2]^.5&
```
Yay. :)
This also works for 22 bytes:
```
Mean[(#-Mean@#)^2]^.5&
```
And this for 27:
```
N@RootMeanSquare[#-Mean@#]&
```
[Answer]
# Octave, 14 bytes
```
g=@(a)std(a,1)
```
Try it on [ideone](http://ideone.com/noczhf).
[Answer]
# [kdb+](http://kx.com/software-download.php), 3 bytes
```
dev
```
One of the APL derviates *had to* have this as a built-in.
### Test run
```
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
```
[Answer]
# Dyalog APL, ~~24~~ ~~23~~ ~~21~~ ~~20~~ ~~19~~ 17 bytes
```
*∘.5∘M×⍨-M×M←+/÷≢
```
This defines an unnamed, monadic function train, which is equivalent to the following function.
```
{.5*⍨M(×⍨⍵)-M⍵×(M←{(+/⍵)÷≢⍵})⍵}
```
Try them online on [TryAPL](http://tryapl.org/?a=%28%20%28*%u2218.5%u2218M%D7%u2368-M%D7M%u2190+/%F7%u2262%29%20%2C%20%7B.5*%u2368M%28%D7%u2368%u2375%29-M%u2375%D7%28M%u2190%7B%28+/%u2375%29%F7%u2262%u2375%7D%29%u2375%7D%20%29%2056%2054%2089%2087&run).
### How it works
The code consists of several trains.
```
M←+/÷≢
```
This defines a monadic 3-train (fork) `M` that executes `+/` (sum of all elements) and `≢` (length) for the right argument, then applies `÷` (division) to the results, returning the arithmetic mean of the input.
```
M×M
```
This is another fork that applies `M` to the right argument, repeats this a second time, and applies `×` (product) to the results, returning **μ2**.
```
×⍨-(M×M)
```
This is yet another fork that calculates the square of the arithmetic mean as explained before, applies `×⍨` (product with itself) to the right argument, and finally applies `-` (difference) to the results.
For input **(x1, …, xN)**, this function returns **(x1 - μ2, …, xN - μ2)**.
```
*∘.5∘M
```
This composed function is applies `M` to its right argument, then `*∘.5`. The latter uses right argument currying to apply map input `a` to `a*0.5` (square root of `a`).
```
(*∘.5∘M)(×⍨-(M×M))
```
Finally, we have this monadic 2-train (atop), which applies the right function first, then the left to its result, calculating the standard deviation as follows.
[![formula](https://i.stack.imgur.com/GH3oK.png)](https://i.stack.imgur.com/GH3oK.png)
[Answer]
# R, ~~41~~ ~~40~~ ~~39~~ ~~36~~ ~~30~~ 28 bytes
### code
Thanks to [beaker](https://codegolf.stackexchange.com/users/42892/beaker), [Alex A.](https://codegolf.stackexchange.com/users/20469/alex-a) and [MickyT](https://codegolf.stackexchange.com/users/31347/mickyt) for much bytes.
```
cat(sd(c(v=scan(),mean(v))))   
```
### old codes
```
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) 
```
This should yield the population standard deviation.
[Answer]
# Julia, ~~26~~ 19 bytes
```
x->std([x;mean(x)])
```
This creates an unnamed function that accepts an array and returns a float.
Ungolfed, I guess:
```
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
```
[Answer]
# Pyth, ~~20~~ ~~19~~ ~~17~~ 13 bytes
```
@.O^R2-R.OQQ2
```
*Thanks to @FryAmTheEggman for golfing off 4 bytes!*
[Try it online.](https://pyth.herokuapp.com/?code=%40.O%5ER2-R.OQQ2&input=56%2C54%2C89%2C87)
### How it works
```
        .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.
```
[Answer]
# CJam, ~~24~~ ~~22~~ 21 bytes
```
q~_,_@_:+d@/f-:mh\mq/
```
*Thanks to @aditsu for golfing off 1 byte!*
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=q~_%2C_%40_%3A%2Bd%40%2Ff-%3Amh%5Cmq%2F&input=%5B56%2054%2089%2087%5D).
### How it works
```
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.
```
[Answer]
# APL, 24 bytes
```
{.5*⍨+/(2*⍨⍵-+/⍵÷≢⍵)÷≢⍵}
```
A little different approach than [Dennis' Dyalog APL solution](https://codegolf.stackexchange.com/a/60913/20469). This should work with any APL implementation.
This creates an unnamed monadic function that computes the vector (*x* - *µ*)2 as `2*⍨⍵-+/⍵÷≢⍵`, divides this by *N* (`÷≢⍵`), takes the sum of this vector using `+/`, and then takes the square root (`.5*⍨`).
[Try it online](http://tryapl.org/?a=%7B.5*%u2368+/%282*%u2368%u2375-+/%u2375%F7%u2262%u2375%29%F7%u2262%u2375%7D%2045%2067%2032%2098%2011%203&run)
[Answer]
# TI-BASIC, 7 bytes
```
stdDev(augment(Ans,{mean(Ans
```
I borrowed the algorithm to get population standard deviation from sample standard deviation from [here](http://tibasicdev.wikidot.com/stddev).
The shortest solution I could find without `augment(` is 9 bytes:
```
stdDev(Ans√(1-1/dim(Ans
```
[Answer]
# Haskell, 61 bytes
```
d n=1/sum(n>>[1])
f a=sqrt$d a*sum(map((^2).(-)(d a*sum a))a)
```
Straightforward, except maybe my custom length function `sum(n>>[1])` to trick Haskell's strict type system. 
[Answer]
# Python 3.4+, 30 bytes
```
from statistics import*;pstdev
```
Imports the builtin function `pstdev`, e.g.
```
>>> pstdev([56,54,89,87])
16.53027525481654
```
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly)
**11 bytes**
```
S÷L
Ç²_²ÇN½
```
This is a direct translation of [my APL answer](https://codegolf.stackexchange.com/a/60913) to Jelly. [Try it online!](http://jelly.tryitonline.net/#code=U8O3TArDh8KyX8Kyw4dOwr0&input=&args=NDUsNjcsMzIsOTgsMTEsMw)
### How it works
```
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.
Ç²_²Ç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.
```
[Answer]
# Prolog (SWI), 119 bytes
**Code:**
```
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).
```
**Explanation:**
```
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
```
**Example:**
```
p([10035, 436844, 42463, 44774]).
175656.78441352615
```
Try it out online [here](http://swish.swi-prolog.org/p/dzwqjuYT.pl)
[Answer]
# J, 18 bytes
```
[:%:@M*:-M*M=:+/%#
```
This is a direct translation of [my APL answer](https://codegolf.stackexchange.com/a/60913) to J.
[Try it online!](https://tio.run/nexus/j#@5@mYGulEG2lauXgq2Wl66vla2ulra@q/D81OSNfIU3BxFTBzFzB2EjB0kLB0FDB@D8A "J – TIO Nexus")
[Answer]
# [Haskell](https://www.haskell.org/), 45 bytes
```
(?)i=sum.map(^i)
f l=sqrt$2?l/0?l-(1?l/0?l)^2
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/X8NeM9O2uDRXLzexQCMuU5MrTSHHtriwqETFyD5H38A@R1fDEMLQjDP6n5uYmadgq1BQlJlXoqCikKYQbWKqY2auY2ykY2mhY2ioYxz7/19yWk5ievF/3eSCAgA "Haskell – Try It Online")
The value `i?l` is the sum of the i'th powers of elements in `l`, so that `0?l` is the length and `1?l` is the sum.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~10~~ 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ÅA-nÅAt
```
-3 bytes thanks to *@ovs*.
[Try it online](https://tio.run/##yy9OTMpM/f//cKujbh6QKPn/P9rCWMfQ0EzH0hxMGRqaxgIA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaXL/8Otjrp5QKLkv87/6GhDAwNjUx0TYzMLExMdEyMTM2MdExNzc5NYnWgTUx0zcx1jIx1LCx1DQx1joJChDhzGxgIA).
**Explanation:**
```
ÅA       # Get the arithmetic mean of the (implicit) input-list
  -      # Subtract it from each value in the (implicit) input-list
   n     # Square each of those
    ÅA   # Take the arithmetic mean of that
      t  # And take the square-root of that
         # (after which it is output implicitly as result)
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 16 bytes
```
⟨∋-⟨+/l⟩⟩ᶠ^₂ᵐ↰₂√
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//9H8FY86unWBlLZ@zqP5K4Ho4bYFcY@amh5unfCobQOQ8ahj1v//0YYGBsamOgomxmYWJiZA2sjEzBhImZibm8T@jwIA "Brachylog – Try It Online") [(all cases at once)](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRu/6htw6Ompoe7Omsfbp3w/9H8FY86unWBlLZ@zqP5K4Ho4bYFcSAVWyeAlbY86pj1/390tKGBgbGpjoKJsZmFiQmQNjIxMwZSJubmJrE6CtEmpjpm5jrGRjqWFjqGhjrGIDFDHTgEcU3NdExNdCwsdSzMQVygchDXDKgvNhYA "Brachylog – Try It Online")
I feel like *maybe* there's some shorter way to compute the squared deviations than 13 bytes.
[Answer]
# [Arn](https://github.com/ZippyMagician/Arn), [~~19~~ ~~18~~ 14 bytes](https://github.com/ZippyMagician/Arn/wiki/Carn)
```
¯‡iʠØbmÅQƥªÈªÆ
```
[Try it!](https://zippymagician.github.io/Arn?code=Oi9tZWFuKG57OipuLW1lYW46c31c&input=MTAwMzUgNDM2ODQ0IDQyNDYzIDQ0Nzc0CjQ1IDY3IDMyIDk4IDExIDMKMSAxIDEgMSAxIDE=)
# Explained
Unpacked: `:/mean(n{:*n-mean:s}\`
```
:/                      Square root
  mean                  Mean function
    (                   Begin expression
        n{              Block with key of n
          :*            Square
              n
            -           Subtraction
              mean
                    _   Variable initialized to STDIN; implied
                  :s    Split on spaces
         }              End of block
       \                Mapped over
         _              Implied
    )                   End of expression; Implied
```
[Answer]
# [Simplex v.0.5](http://conorobrien-foxx.github.io/Simplex/), 43 bytes
Just 'cuz. I really need to golf this one more byte.
```
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
```
[Answer]
# JavaScript (ES6), 73 bytes
```
a=>Math.sqrt(a.reduce((b,c)=>b+(d=c-eval(a.join`+`)/(l=a.length))*d,0)/l)
```
[Answer]
# Perl5, ~~39~~ 38
---
 16 for the script  
+22 for the `M` switch  
+ 1 for the `E` switch  
```
perl -MStatistics::Lite=:all -E"say stddevp@ARGV" .1 .2 300
```
Tested in Strawberry 5.20.2.
---
Oh, but then I realized that you said our answers can be functions instead of programs. In that case,
```
{use Statistics::Lite":all";stddevp@_}
```
has just 38. Tested in Strawberry 5.20.2 as
```
print sub{use Statistics::Lite":all";stddevp@_}->( .1, .2, 300)
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), ~~10~~ 7 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
ë_▓-²▓√
```
Port of [my 05AB1E answer](https://codegolf.stackexchange.com/a/210034/52210).
[Try it online.](https://tio.run/##y00syUjPz0n7///w6vhH0ybrHtoEJB91zPr/39DAwNhUwcTYzMLERMHEyMTMWMHExNzchMvEVMHMXMHYSMHSQsHQUMGYy1ABDgE)
**Explanation:**
```
ë        # Read all inputs as float-list
 _       # Duplicate that list
  ▓      # Get the average of that list
   -     # Subtract that average from each value in the list
    ²    # Square each value
     ▓   # Take the average of that again
      √  # And take the square root of that
         # (after which the entire stack joined together is output implicitly as result)
```
[Answer]
# [Whispers v2](https://github.com/cairdcoinheringaahing/Whispers), 105 bytes
```
> Input
>> #1
>> ∑1
>> 3÷2
>> L-4
>> L²
>> Each 5 1
>> Each 6 7
>> ∑8
>> 9÷2
>> √10
>> Output 11
```
[Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fTsEzr6C0hMvOTkHZEEQ@6pgIpo0PbzcC0T66JmDq0CYQ5ZqYnKFgqmAIZ5spmEN1WYBoS6iuRx2zDA1ADP/SEqDxCoaG//9HGxoYGJvqKJgYm1mYmABpIxMzYyBlYm5uEgsA "Whispers v2 – Try It Online")
In the latest version of Whispers, the builtin [`σ`](https://github.com/cairdcoinheringaahing/Whispers/blob/master/whispers%20v3.py#L1474) can be used to shave off around 70 bytes.
## How it works
For those unfamiliar with Whispers, the language works by using numbers as line references in order to pass values between lines. For example, the line `>> 3÷2` doesn't calculate \$3 \div 2\$, rather it takes the values of lines **3** and **2** and calculates their division. Execution always begins on the last line.
This program simply implements the standard formula for standard deviation:
$$\sigma = \sqrt{\frac{1}{N}\sum^N\_{i=1}{(x\_i-\bar{x})^2}}$$
$$\bar{x} = \frac{1}{N}\sum^N\_{i=1}{x\_i}$$
Lines **2**, **3** and **4** define \$\bar{x}\$, with it's specific value accessible on line **4**. Line **2** stores \$N\$. We then calculate \$(x\_i-\bar{x})^2\$ for each \$x\_i \in x\$ with the lines **5**, **6**, **7** and **8**:
```
>> L-4
>> L²
>> Each 5 1
>> Each 6 7
```
Line **7** runs line **5** over each element in the input, which takes the difference between each element in the input and the mean, We then square these differences using lines **8** and **6**. Finally, we take the sum of these squares (line **9**), divide by \$N\$ (line **10**) and take the square root (line **11**). Finally, we output this result.
[Answer]
# [Shasta v0.0.10](https://github.com/jacobofbrooklyn/shasta/tree/d66d19a634eb70bd73feac1972327867a7f0ede4), 65 bytes
```
{(**(/(sum(map${|x|(**(- x(/(sum$)(length$)))2)}))(length$)).5)}
```
Online interpreter not set up yet, tested on my machine
Explanation:
`{...}` Function taking argument $
`(** ... .5)` Square root of
`(/ ... (length $))` Dividing ... by the length of $
`(sum ...)` The sum of
`(map $ {|x| ...})` Mapping each x in $ to
`(** ... 2)` The square of
`(- x ...)` The difference between x and
`(/ (sum $) (length $))` The mean of $
[Answer]
# Python, 57 bytes
```
lambda l:(sum((x-sum(l)/len(l))**2for x in l)/len(l))**.5
```
Takes input as a list
Thanks @xnor
[Answer]
### 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)
```
explanation
```
<#
$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
#>
```
result
```
:\>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
```
[Answer]
# Fortran, 138 bytes
Just a straightforward implementation of the equation in 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
```
[Answer]
# SmileBASIC, 105 bytes (as a function)
I just noticed it's allowed to be a function. Whoops, that reduces my answer dramatically. This defines a function `S` which takes an array and returns the population standard deviation. Go read the other one for an explanation, but skip the parsing part. I don't want to do it again.
```
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
```
## As a program, 212 bytes
Unfortunately, I have to take the input list as a string and parse it myself. This adds over 100 bytes to the answer, so if some input format other than a comma-separated list is allowed I'd be glad to hear it. Also note that because `VAL` is buggy, having a space *before* the comma or trailing the string breaks the program. After the comma or at the start of the string is fine.
```
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 and explained:
```
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)
```
]